fix a typo: --string-exp => --strings-exp; fix a signed int warning in antlr

2 files changed, 171 insertions, 171 deletions

diff --git a/src/util/regexp.cpp b/src/util/regexp.cpp
index 3e2fa948c..c0e2947cb 100644
--- a/src/util/regexp.cpp
+++ b/src/util/regexp.cpp
@@ -27,122 +27,122 @@ void String::toInternal(const std::string &s) {
   d_str.clear();

   unsigned i=0;

   while(i < s.size()) {

-	  if(s[i] == '\\') {

-		  i++;

-		  if(i < s.size()) {

-			  switch(s[i]) {

-				  case 'n':  {d_str.push_back( convertCharToUnsignedInt('\n') );i++;} break;

-				  case 't':  {d_str.push_back( convertCharToUnsignedInt('\t') );i++;} break;

-				  case 'v':  {d_str.push_back( convertCharToUnsignedInt('\v') );i++;} break;

-				  case 'b':  {d_str.push_back( convertCharToUnsignedInt('\b') );i++;} break;

-				  case 'r':  {d_str.push_back( convertCharToUnsignedInt('\r') );i++;} break;

-				  case 'f':  {d_str.push_back( convertCharToUnsignedInt('\f') );i++;} break;

-				  case 'a':  {d_str.push_back( convertCharToUnsignedInt('\a') );i++;} break;

-				  case '\\': {d_str.push_back( convertCharToUnsignedInt('\\') );i++;} break;

-				  case 'x': {

-					  if(i + 2 < s.size()) {

-						if((isdigit(s[i+1]) || (s[i+1] >= 'a' && s[i+1] >= 'f') || (s[i+1] >= 'A' && s[i+1] >= 'F')) &&

-						   (isdigit(s[i+2]) || (s[i+2] >= 'a' && s[i+2] >= 'f') || (s[i+2] >= 'A' && s[i+2] >= 'F'))) {

-							d_str.push_back( convertCharToUnsignedInt( hexToDec(s[i+1]) * 16 + hexToDec(s[i+2]) ) );

-							i += 3;

-						} else {

-							throw CVC4::Exception( "Error String Literal: \"" + s + "\"" );

-						}

-					  } else {

-						throw CVC4::Exception( "Error String Literal: \"" + s + "\"" );

-					  }

-				  }

-				  break;

-				  default: {

-					  if(isdigit(s[i])) {

-						  int num = (int)s[i] - (int)'0';

-						  bool flag = num < 4;

-						  if(i+1 < s.size() && num < 8 && isdigit(s[i+1]) && s[i+1] < '8') {

-							  num = num * 8 + (int)s[i+1] - (int)'0';

-							  if(flag && i+2 < s.size() && isdigit(s[i+2]) && s[i+2] < '8') {

-								  num = num * 8 + (int)s[i+2] - (int)'0';

-								  d_str.push_back( convertCharToUnsignedInt((char)num) );

-								  i += 3;

-							  } else {

-								  d_str.push_back( convertCharToUnsignedInt((char)num) );

-								  i += 2;

-							  }

-						  } else {

-							  d_str.push_back( convertCharToUnsignedInt((char)num) );

-							  i++;

-						  }

-					  } else {

-						  d_str.push_back( convertCharToUnsignedInt(s[i]) );

-						  i++;

-					  }

-				  }

-			  }

-		  } else {

-			  throw CVC4::Exception( "should be handled by lexer: \"" + s + "\"" );

-			  //d_str.push_back( convertCharToUnsignedInt('\\') );

-		  }

-	  } else {

-		  d_str.push_back( convertCharToUnsignedInt(s[i]) );

-		  i++;

-	  }

+    if(s[i] == '\\') {

+      i++;

+      if(i < s.size()) {

+        switch(s[i]) {

+          case 'n':  {d_str.push_back( convertCharToUnsignedInt('\n') );i++;} break;

+          case 't':  {d_str.push_back( convertCharToUnsignedInt('\t') );i++;} break;

+          case 'v':  {d_str.push_back( convertCharToUnsignedInt('\v') );i++;} break;

+          case 'b':  {d_str.push_back( convertCharToUnsignedInt('\b') );i++;} break;

+          case 'r':  {d_str.push_back( convertCharToUnsignedInt('\r') );i++;} break;

+          case 'f':  {d_str.push_back( convertCharToUnsignedInt('\f') );i++;} break;

+          case 'a':  {d_str.push_back( convertCharToUnsignedInt('\a') );i++;} break;

+          case '\\': {d_str.push_back( convertCharToUnsignedInt('\\') );i++;} break;

+          case 'x': {

+            if(i + 2 < s.size()) {

+            if((isdigit(s[i+1]) || (s[i+1] >= 'a' && s[i+1] >= 'f') || (s[i+1] >= 'A' && s[i+1] >= 'F')) &&

+               (isdigit(s[i+2]) || (s[i+2] >= 'a' && s[i+2] >= 'f') || (s[i+2] >= 'A' && s[i+2] >= 'F'))) {

+              d_str.push_back( convertCharToUnsignedInt( hexToDec(s[i+1]) * 16 + hexToDec(s[i+2]) ) );

+              i += 3;

+            } else {

+              throw CVC4::Exception( "Error String Literal: \"" + s + "\"" );

+            }

+            } else {

+            throw CVC4::Exception( "Error String Literal: \"" + s + "\"" );

+            }

+          }

+          break;

+          default: {

+            if(isdigit(s[i])) {

+              int num = (int)s[i] - (int)'0';

+              bool flag = num < 4;

+              if(i+1 < s.size() && num < 8 && isdigit(s[i+1]) && s[i+1] < '8') {

+                num = num * 8 + (int)s[i+1] - (int)'0';

+                if(flag && i+2 < s.size() && isdigit(s[i+2]) && s[i+2] < '8') {

+                  num = num * 8 + (int)s[i+2] - (int)'0';

+                  d_str.push_back( convertCharToUnsignedInt((char)num) );

+                  i += 3;

+                } else {

+                  d_str.push_back( convertCharToUnsignedInt((char)num) );

+                  i += 2;

+                }

+              } else {

+                d_str.push_back( convertCharToUnsignedInt((char)num) );

+                i++;

+              }

+            } else {

+              d_str.push_back( convertCharToUnsignedInt(s[i]) );

+              i++;

+            }

+          }

+        }

+      } else {

+        throw CVC4::Exception( "should be handled by lexer: \"" + s + "\"" );

+        //d_str.push_back( convertCharToUnsignedInt('\\') );

+      }

+    } else {

+      d_str.push_back( convertCharToUnsignedInt(s[i]) );

+      i++;

+    }

   }

 }

 

 void String::getCharSet(std::set<unsigned int> &cset) const {

-	for(std::vector<unsigned int>::const_iterator itr = d_str.begin();

-		itr != d_str.end(); itr++) {

-			cset.insert( *itr );

-		}

+  for(std::vector<unsigned int>::const_iterator itr = d_str.begin();

+    itr != d_str.end(); itr++) {

+      cset.insert( *itr );

+    }

 }

 

 bool String::overlap(String &y) const {

-	unsigned n = d_str.size() < y.size() ? d_str.size() : y.size();

-	for(unsigned i=1; i<n; i++) {

-		String s = suffix(i);

-		String p = y.prefix(i);

-		if(s == p) {

-			return true;

-		}

-	}

-	return false;

+  unsigned n = d_str.size() < y.size() ? d_str.size() : y.size();

+  for(unsigned i=1; i<n; i++) {

+    String s = suffix(i);

+    String p = y.prefix(i);

+    if(s == p) {

+      return true;

+    }

+  }

+  return false;

 }

 

 std::string String::toString() const {

-	std::string str;

-	for(unsigned int i=0; i<d_str.size(); ++i) {

-	  char c = convertUnsignedIntToChar( d_str[i] );

-	  if(isprint( c )) {

-		if(c == '\\') {

-			str += "\\\\";

-		} else if(c == '\"') {

-			str += "\\\"";

-		} else {

-			str += c;

-		}

-	  } else {

-		  std::string s;

-		  switch(c) {

-			case '\a': s = "\\a"; break;

-			case '\b': s = "\\b"; break;

-			case '\t': s = "\\t"; break;

-			case '\r': s = "\\r"; break;

-			case '\v': s = "\\v"; break;

-			case '\f': s = "\\f"; break;

-			case '\n': s = "\\n"; break;

-			case '\e': s = "\\e"; break;

-			default  : {

-				std::stringstream ss;

-				ss << std::setfill ('0') << std::setw(2) << std::hex << ((int)c);

-				std::string t = ss.str();

-				t = t.substr(t.size()-2, 2);

-				s = "\\x" + t;

-				//std::string s2 = static_cast<std::ostringstream*>( &(std::ostringstream() << (int)c) )->str();

-			}

-		  }

-		  str += s;

-	  }

-	}

-	return str;

+  std::string str;

+  for(unsigned int i=0; i<d_str.size(); ++i) {

+    char c = convertUnsignedIntToChar( d_str[i] );

+    if(isprint( c )) {

+    if(c == '\\') {

+      str += "\\\\";

+    } else if(c == '\"') {

+      str += "\\\"";

+    } else {

+      str += c;

+    }

+    } else {

+      std::string s;

+      switch(c) {

+      case '\a': s = "\\a"; break;

+      case '\b': s = "\\b"; break;

+      case '\t': s = "\\t"; break;

+      case '\r': s = "\\r"; break;

+      case '\v': s = "\\v"; break;

+      case '\f': s = "\\f"; break;

+      case '\n': s = "\\n"; break;

+      case '\e': s = "\\e"; break;

+      default  : {

+        std::stringstream ss;

+        ss << std::setfill ('0') << std::setw(2) << std::hex << ((int)c);

+        std::string t = ss.str();

+        t = t.substr(t.size()-2, 2);

+        s = "\\x" + t;

+        //std::string s2 = static_cast<std::ostringstream*>( &(std::ostringstream() << (int)c) )->str();

+      }

+      }

+      str += s;

+    }

+  }

+  return str;

 }

 

 std::ostream& operator <<(std::ostream& os, const String& s) {

diff --git a/src/util/regexp.h b/src/util/regexp.h
index 1ae01343d..b7eea929d 100644
--- a/src/util/regexp.h
+++ b/src/util/regexp.h
@@ -61,13 +61,13 @@ private:
 
   //guarded
   char hexToDec(char c) {
-	  if(isdigit(c)) {
-		  return c - '0';
-	  } else if (c >= 'a' && c >= 'f') {
-		  return c - 'a' + 10;
-	  } else {
-		  return c - 'A' + 10;
-	  }
+    if(isdigit(c)) {
+      return c - '0';
+    } else if (c >= 'a' && c >= 'f') {
+      return c - 'a' + 10;
+    } else {
+      return c - 'A' + 10;
+    }
   }
 
   void toInternal(const std::string &s);
@@ -164,11 +164,11 @@ public:
   }
 
   bool isEmptyString() const {
-	  return ( d_str.size() == 0 );
+    return ( d_str.size() == 0 );
   }
 
   unsigned int operator[] (const unsigned int i) const {
-	//Assert( i < d_str.size() && i >= 0);
+  //Assert( i < d_str.size() && i >= 0);
     return d_str[i];
   }
   /*
@@ -185,54 +185,54 @@ public:
   }
 
   bool isRepeated() const {
-	if(d_str.size() > 1) {
-		unsigned int f = d_str[0];
-		for(unsigned i=1; i<d_str.size(); ++i) {
-			if(f != d_str[i]) return false;
-		}
-	}
-	return true;
+  if(d_str.size() > 1) {
+    unsigned int f = d_str[0];
+    for(unsigned i=1; i<d_str.size(); ++i) {
+      if(f != d_str[i]) return false;
+    }
+  }
+  return true;
   }
 
   bool tailcmp(const String &y, int &c) const {
-	  int id_x = d_str.size() - 1;
-	  int id_y = y.d_str.size() - 1;
-	  while(id_x>=0 && id_y>=0) {
-		  if(d_str[id_x] != y.d_str[id_y]) {
-			  c = id_x;
-			  return false;
-		  }
-		  --id_x; --id_y;
-	  }
-	  c = id_x == -1 ? ( - (id_y+1) ) : (id_x + 1);
-	  return true;
+    int id_x = d_str.size() - 1;
+    int id_y = y.d_str.size() - 1;
+    while(id_x>=0 && id_y>=0) {
+      if(d_str[id_x] != y.d_str[id_y]) {
+        c = id_x;
+        return false;
+      }
+      --id_x; --id_y;
+    }
+    c = id_x == -1 ? ( - (id_y+1) ) : (id_x + 1);
+    return true;
   }
 
   std::size_t find(const String &y, const int start = 0) const {
-	  if(d_str.size() < y.d_str.size() + (std::size_t) start) return std::string::npos;
-	  if(y.d_str.size() == 0) return (std::size_t) start;
-	  if(d_str.size() == 0) return std::string::npos;
-	  std::size_t ret = std::string::npos;
-	  for(int i = start; i <= (int) d_str.size() - (int) y.d_str.size(); i++) {
-		  if(d_str[i] == y.d_str[0]) {
-			  std::size_t j=0;
-			  for(; j<y.d_str.size(); j++) {
-				  if(d_str[i+j] != y.d_str[j]) break;
-			  }
-			  if(j == y.d_str.size()) {
-				  ret = (std::size_t) i;
-				  break;
-			  }
-		  }
-	  }
-	  return ret;
+    if(d_str.size() < y.d_str.size() + (std::size_t) start) return std::string::npos;
+    if(y.d_str.size() == 0) return (std::size_t) start;
+    if(d_str.size() == 0) return std::string::npos;
+    std::size_t ret = std::string::npos;
+    for(int i = start; i <= (int) d_str.size() - (int) y.d_str.size(); i++) {
+      if(d_str[i] == y.d_str[0]) {
+        std::size_t j=0;
+        for(; j<y.d_str.size(); j++) {
+          if(d_str[i+j] != y.d_str[j]) break;
+        }
+        if(j == y.d_str.size()) {
+          ret = (std::size_t) i;
+          break;
+        }
+      }
+    }
+    return ret;
   }
 
   String replace(const String &s, const String &t) const {
     std::size_t ret = find(s);
     if( ret != std::string::npos ) {
       std::vector<unsigned int> vec;
-      vec.insert(vec.begin(), d_str.begin(), d_str.begin() + ret); 
+      vec.insert(vec.begin(), d_str.begin(), d_str.begin() + ret);
       vec.insert(vec.end(), t.d_str.begin(), t.d_str.end());
       vec.insert(vec.end(), d_str.begin() + ret + s.d_str.size(), d_str.end());
       return String(vec);
@@ -255,34 +255,34 @@ public:
   }
 
   String prefix(unsigned i) const {
-	  return substr(0, i);
+    return substr(0, i);
   }
   String suffix(unsigned i) const {
-	  return substr(d_str.size() - i, i);
+    return substr(d_str.size() - i, i);
   }
   bool overlap(String &y) const;
 
   bool isNumber() const {
-	 if(d_str.size() == 0) return false;
-	 for(unsigned int i=0; i<d_str.size(); ++i) {
-	   char c = convertUnsignedIntToChar( d_str[i] );
-	   if(c<'0' || c>'9') {
-		   return false;
-	   }
-	 }
-	 return true;
+   if(d_str.size() == 0) return false;
+   for(unsigned int i=0; i<d_str.size(); ++i) {
+     char c = convertUnsignedIntToChar( d_str[i] );
+     if(c<'0' || c>'9') {
+       return false;
+     }
+   }
+   return true;
   }
   int toNumber() const {
-	 if(isNumber()) {
-		 int ret=0;
-		 for(unsigned int i=0; i<d_str.size(); ++i) {
-		   char c = convertUnsignedIntToChar( d_str[i] );
-		   ret = ret * 10 + (int)c - (int)'0';
-		 }
-		 return ret;
-	 } else {
-		 return -1;
-	 }
+   if(isNumber()) {
+     int ret=0;
+     for(unsigned int i=0; i<d_str.size(); ++i) {
+       char c = convertUnsignedIntToChar( d_str[i] );
+       ret = ret * 10 + (int)c - (int)'0';
+     }
+     return ret;
+   } else {
+     return -1;
+   }
   }
   void getCharSet(std::set<unsigned int> &cset) const;
 };/* class String */