Various Ice-E fixes:

- Bug fix in slice2javae for local interfaces/classes
- Added Ice.LocalObjectHolder
- Reviewed Java/C++ demos and aligned with Ice
- Source code clean up (removed tabs, etc.)

1 files changed, 191 insertions, 191 deletions

diff --git a/cppe/src/IceE/StringUtil.cpp b/cppe/src/IceE/StringUtil.cpp
index c728e3151a2..7cce1177fd6 100644
--- a/cppe/src/IceE/StringUtil.cpp
+++ b/cppe/src/IceE/StringUtil.cpp
@@ -42,86 +42,86 @@ encodeChar(string::value_type b, string& s, const string& special)
 {
     switch(b)
     {
-	case '\\': 
-	{
-	    s.append("\\\\");
-	    break;
-	}
-	
-	case '\'': 
-	{
-	    s.append("\\'");
-	    break;
-	}
-	
-	case '"': 
-	{
-	    s.append("\\\"");
-	    break;
-	}
-	
-	case '\b': 
-	{
-	    s.append("\\b");
-	    break;
-	}
-	
-	case '\f': 
-	{
-	    s.append("\\f");
-	    break;
-	}
-	
-	case '\n': 
-	{
-	    s.append("\\n");
-	    break;
-	}
-	
-	case '\r': 
-	{
-	    s.append("\\r");
-	    break;
-	}
-	
-	case '\t': 
-	{
-	    s.append("\\t");
-	    break;
-	}
-	
-	default: 
-	{
-	    unsigned char i = static_cast<unsigned char>(b);
-	    if(!(i >= 32 && i <= 126))
-	    {
-		s.push_back('\\');
-		string octal = toOctalString(i);
-		//
-		// Add leading zeroes so that we avoid problems during
-		// decoding. For example, consider the escaped string
-		// \0013 (i.e., a character with value 1 followed by the
-		// character '3'). If the leading zeroes were omitted, the
-		// result would be incorrectly interpreted as a single
-		// character with value 11.
-		//
-		for(string::size_type j = octal.size(); j < 3; j++)
-		{
-		    s.push_back('0');
-		}
-		s.append(octal);
-	    }
-	    else if(special.find(b) != string::npos)
-	    {
-		s.push_back('\\');
-		s.push_back(b);
-	    }
-	    else
-	    {
-		s.push_back(b);
-	    }
-	    break;
-	}
+        case '\\': 
+        {
+            s.append("\\\\");
+            break;
+        }
+        
+        case '\'': 
+        {
+            s.append("\\'");
+            break;
+        }
+        
+        case '"': 
+        {
+            s.append("\\\"");
+            break;
+        }
+        
+        case '\b': 
+        {
+            s.append("\\b");
+            break;
+        }
+        
+        case '\f': 
+        {
+            s.append("\\f");
+            break;
+        }
+        
+        case '\n': 
+        {
+            s.append("\\n");
+            break;
+        }
+        
+        case '\r': 
+        {
+            s.append("\\r");
+            break;
+        }
+        
+        case '\t': 
+        {
+            s.append("\\t");
+            break;
+        }
+        
+        default: 
+        {
+            unsigned char i = static_cast<unsigned char>(b);
+            if(!(i >= 32 && i <= 126))
+            {
+                s.push_back('\\');
+                string octal = toOctalString(i);
+                //
+                // Add leading zeroes so that we avoid problems during
+                // decoding. For example, consider the escaped string
+                // \0013 (i.e., a character with value 1 followed by the
+                // character '3'). If the leading zeroes were omitted, the
+                // result would be incorrectly interpreted as a single
+                // character with value 11.
+                //
+                for(string::size_type j = octal.size(); j < 3; j++)
+                {
+                    s.push_back('0');
+                }
+                s.append(octal);
+            }
+            else if(special.find(b) != string::npos)
+            {
+                s.push_back('\\');
+                s.push_back(b);
+            }
+            else
+            {
+                s.push_back(b);
+            }
+            break;
+        }
     }
 }
 
@@ -136,16 +136,16 @@ IceUtil::escapeString(const string& s, const string& special)
     string::size_type i;
     for(i = 0; i < special.size(); ++i)
     {
-	if(static_cast<unsigned char>(special[i]) < 32 || static_cast<unsigned char>(special[i]) > 126)
-	{
-	    throw IllegalArgumentException(__FILE__, __LINE__, "special characters must be in ASCII range 32-126");
-	}
+        if(static_cast<unsigned char>(special[i]) < 32 || static_cast<unsigned char>(special[i]) > 126)
+        {
+            throw IllegalArgumentException(__FILE__, __LINE__, "special characters must be in ASCII range 32-126");
+        }
     }
     
     string result;
     for(i = 0; i < s.size(); ++i)
     {
-	encodeChar(s[i], result, special);
+        encodeChar(s[i], result, special);
     }
     
     return result;
@@ -178,86 +178,86 @@ decodeChar(const string& s, string::size_type start, string::size_type end, stri
 
     if(s[start] != '\\')
     {
-	c = checkChar(s[start++]);
+        c = checkChar(s[start++]);
     }
     else
     {
-	if(start + 1 == end)
-	{
-	    throw IllegalArgumentException(__FILE__, __LINE__, "trailing backslash in argument");
-	}
-	switch(s[++start])
-	{
-	    case '\\': 
-	    case '\'': 
-	    case '"': 
-	    {
-		c = s[start++];
-		break;
-	    }
-	    case 'b': 
-	    {
-		++start;
-		c = '\b';
-		break;
-	    }
-	    case 'f': 
-	    {
-		++start;
-		c = '\f';
-		break;
-	    }
-	    case 'n': 
-	    {
-		++start;
-		c = '\n';
-		break;
-	    }
-	    case 'r': 
-	    {
-		++start;
-		c = '\r';
-		break;
-	    }
-	    case 't': 
-	    {
-		++start;
-		c = '\t';
-		break;
-	    }
-	    case '0':
-	    case '1':
-	    case '2':
-	    case '3':
-	    case '4':
-	    case '5':
-	    case '6':
-	    case '7':
-	    {
-		int oct = 0;
-		for(int j = 0; j < 3 && start < end; ++j)
-		{
-		    int charVal = s[start++] - '0';
-		    if(charVal < 0 || charVal > 7)
-		    {
-		        --start;
-			break;
-		    }
-		    oct = oct * 8 + charVal;
-		}
-		if(oct > 255)
-		{
-		    throw IllegalArgumentException(__FILE__, __LINE__, "octal value out of range");
-		}
-		c = (char)oct;
-		break;
-	    }
-	    default:
-	    {
-		c = checkChar(s[start++]);
-		break;
-	    }
-	}
+        if(start + 1 == end)
+        {
+            throw IllegalArgumentException(__FILE__, __LINE__, "trailing backslash in argument");
+        }
+        switch(s[++start])
+        {
+            case '\\': 
+            case '\'': 
+            case '"': 
+            {
+                c = s[start++];
+                break;
+            }
+            case 'b': 
+            {
+                ++start;
+                c = '\b';
+                break;
+            }
+            case 'f': 
+            {
+                ++start;
+                c = '\f';
+                break;
+            }
+            case 'n': 
+            {
+                ++start;
+                c = '\n';
+                break;
+            }
+            case 'r': 
+            {
+                ++start;
+                c = '\r';
+                break;
+            }
+            case 't': 
+            {
+                ++start;
+                c = '\t';
+                break;
+            }
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            {
+                int oct = 0;
+                for(int j = 0; j < 3 && start < end; ++j)
+                {
+                    int charVal = s[start++] - '0';
+                    if(charVal < 0 || charVal > 7)
+                    {
+                        --start;
+                        break;
+                    }
+                    oct = oct * 8 + charVal;
+                }
+                if(oct > 255)
+                {
+                    throw IllegalArgumentException(__FILE__, __LINE__, "octal value out of range");
+                }
+                c = (char)oct;
+                break;
+            }
+            default:
+            {
+                c = checkChar(s[start++]);
+                break;
+            }
+        }
     }
     nextStart = start;
     return c;
@@ -271,7 +271,7 @@ static void decodeString(const string& s, string::size_type start, string::size_
 {
     while(start < end)
     {
-	sb.push_back(decodeChar(s, start, end, start));
+        sb.push_back(decodeChar(s, start, end, start));
     }
 }
 
@@ -291,20 +291,20 @@ IceUtil::unescapeString(const string& s, string::size_type start, string::size_t
     }
     if(start > end)
     {
-	throw IllegalArgumentException(__FILE__, __LINE__, "start offset must <= end offset");
+        throw IllegalArgumentException(__FILE__, __LINE__, "start offset must <= end offset");
     }
 
     result.reserve(end - start);
 
     try
     {
-	result.clear();
-	decodeString(s, start, end, result);
-	return true;
+        result.clear();
+        decodeString(s, start, end, result);
+        return true;
     }
     catch(...)
     {
-	return false;
+        return false;
     }
 }
 
@@ -373,29 +373,29 @@ IceUtil::match(const string& s, const string& pat, bool matchPeriod)
     do
     {
         if(pat[patIndex] == '*')
-	{
-	    //
-	    // Don't allow matching x..y against x.*.y if requested -- star matches non-empty sequence only.
-	    //
-	    if(!matchPeriod && s[sIndex] == '.')
-	    {
-		return false;
-	    }
-	    while(sIndex < s.size() && (matchPeriod || s[sIndex] != '.'))
-	    {
-	        ++sIndex;
-	    }
-	    patIndex++;
-	}
-	else
-	{
-	    if(pat[patIndex] != s[sIndex])
-	    {
-		return false;
-	    }
-	    ++sIndex;
-	    ++patIndex;
-	}
+        {
+            //
+            // Don't allow matching x..y against x.*.y if requested -- star matches non-empty sequence only.
+            //
+            if(!matchPeriod && s[sIndex] == '.')
+            {
+                return false;
+            }
+            while(sIndex < s.size() && (matchPeriod || s[sIndex] != '.'))
+            {
+                ++sIndex;
+            }
+            patIndex++;
+        }
+        else
+        {
+            if(pat[patIndex] != s[sIndex])
+            {
+                return false;
+            }
+            ++sIndex;
+            ++patIndex;
+        }
     }
     while(sIndex < s.size() && patIndex < pat.size());