diff --git a/user/src/com/google/gwt/user/server/rpc/impl/ServerSerializationStreamReader.java b/user/src/com/google/gwt/user/server/rpc/impl/ServerSerializationStreamReader.java
index cb5bf63..55274a6 100644
--- a/user/src/com/google/gwt/user/server/rpc/impl/ServerSerializationStreamReader.java
+++ b/user/src/com/google/gwt/user/server/rpc/impl/ServerSerializationStreamReader.java
@@ -457,12 +457,18 @@
   }
 
   public byte readByte() throws SerializationException {
-    return Byte.parseByte(extract());
+    String value = extract();
+    try {
+      return Byte.parseByte(value);
+    } catch (NumberFormatException e) {
+      throw getNumberFormatException(value, "byte",
+          Byte.MIN_VALUE, Byte.MAX_VALUE);
+    }
   }
 
   public char readChar() throws SerializationException {
     // just use an int, it's more foolproof
-    return (char) Integer.parseInt(extract());
+    return (char) readInt();
   }
 
   public double readDouble() throws SerializationException {
@@ -474,7 +480,13 @@
   }
 
   public int readInt() throws SerializationException {
-    return Integer.parseInt(extract());
+    String value = extract();
+    try {
+      return Integer.parseInt(value);
+    } catch (NumberFormatException e) {
+      throw getNumberFormatException(value, "int",
+          Integer.MIN_VALUE, Integer.MAX_VALUE);
+    }
   }
 
   public long readLong() throws SerializationException {
@@ -484,7 +496,13 @@
   }
 
   public short readShort() throws SerializationException {
-    return Short.parseShort(extract());
+    String value = extract();
+    try {
+      return Short.parseShort(value);
+    } catch (NumberFormatException e) {
+      throw getNumberFormatException(value, "short",
+          Short.MIN_VALUE, Short.MAX_VALUE);
+    }
   }
 
   public String readString() throws SerializationException {
@@ -771,6 +789,36 @@
       throw new SerializationException("Too few tokens in RPC request", e);
     }
   }
+  
+  /**
+   * Returns a suitable NumberFormatException with an explanatory message
+   * when a numerical value cannot be parsed according to its expected
+   * type.
+   *  
+   * @param value the value as read from the RPC stream
+   * @param type the name of the expected type
+   * @param minValue the smallest valid value for the expected type
+   * @param maxValue the largest valid value for the expected type
+   * @return a NumberFormatException with an explanatory message
+   */
+  private NumberFormatException getNumberFormatException(String value,
+      String type, double minValue, double maxValue) {
+    String message = "a non-numerical value";
+    try {
+      // Check the field contents in order to produce a more comprehensible
+      // error message
+      double d = Double.parseDouble(value);
+      if (d < minValue || d > maxValue) {
+        message = "an out-of-range value";
+      } else if (d != Math.floor(d)) {
+        message = "a fractional value";
+      }
+    } catch (NumberFormatException e2) {
+    }
+
+    return new NumberFormatException("Expected type '" + type + "' but received " +
+        message + ": " + value);
+  }
 
   /**
    * Returns a Map from a field name to the setter method for that field, for a
diff --git a/user/test/com/google/gwt/user/server/rpc/RPCTest.java b/user/test/com/google/gwt/user/server/rpc/RPCTest.java
index f59efd6..47a7b2b 100644
--- a/user/test/com/google/gwt/user/server/rpc/RPCTest.java
+++ b/user/test/com/google/gwt/user/server/rpc/RPCTest.java
@@ -18,6 +18,7 @@
 import static com.google.gwt.user.client.rpc.impl.AbstractSerializationStream.RPC_SEPARATOR_CHAR;
 
 import com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException;
+import com.google.gwt.user.client.rpc.IsSerializable;
 import com.google.gwt.user.client.rpc.RemoteService;
 import com.google.gwt.user.client.rpc.SerializableException;
 import com.google.gwt.user.client.rpc.SerializationException;
@@ -68,6 +69,24 @@
     void method1();
   }
 
+  /**
+   * Test error message for an out=of-range int value.
+   * 
+   * @see RPCTest#testDecodeBadIntegerValue()
+   */
+  private static class Wrapper implements IsSerializable {
+    byte value1;
+    char value2;
+    short value3;
+    int value4;
+    public Wrapper() { }
+  }
+
+  @SuppressWarnings("rpc-validation")
+  private static interface WrapperIF extends RemoteService {
+    void method1(Wrapper w);
+  }
+
   private static final String VALID_ENCODED_REQUEST = ""
       + AbstractSerializationStream.SERIALIZATION_STREAM_VERSION
       + RPC_SEPARATOR_CHAR + // version
@@ -164,6 +183,90 @@
       "1\uffff" + // interface name
       "2\uffff" + // method name
       "0\uffff"; // param count
+  
+  /**
+   * Tests that out-of-range or other illegal integer values generated
+   * by client-side serialization get a nested exception with a reasonable
+   * error message.
+   */
+  public void testDecodeBadIntegerValue() {
+    String requestBase = "" +
+        AbstractSerializationStream.SERIALIZATION_STREAM_VERSION +
+        RPC_SEPARATOR_CHAR + // version
+        "0" + RPC_SEPARATOR_CHAR + // flags
+        "6" + RPC_SEPARATOR_CHAR + // string table entry count
+        WrapperIF.class.getName() + RPC_SEPARATOR_CHAR + // string table entry #1
+        "method1" + RPC_SEPARATOR_CHAR + // string table entry #2
+        "moduleBaseURL" + RPC_SEPARATOR_CHAR + // string table entry #3
+        "whitelistHashcode" + RPC_SEPARATOR_CHAR + // string table entry #4
+        Wrapper.class.getName() + RPC_SEPARATOR_CHAR + // string table entry #5
+        Wrapper.class.getName() +
+        "/316143997" + RPC_SEPARATOR_CHAR + // string table entry #6
+        "3" + RPC_SEPARATOR_CHAR + // module base URL
+        "4" + RPC_SEPARATOR_CHAR + // whitelist hashcode
+        "1" + RPC_SEPARATOR_CHAR + // interface name
+        "2" + RPC_SEPARATOR_CHAR + // method name
+        "1" + RPC_SEPARATOR_CHAR + // param count
+        "5" + RPC_SEPARATOR_CHAR + // IntWrapper class name
+        "6" + RPC_SEPARATOR_CHAR; // IntWrapper signature
+    
+    // Valid values
+    String goodRequest = requestBase + "12" + RPC_SEPARATOR_CHAR + // byte
+    "345" + RPC_SEPARATOR_CHAR + // char
+    "678" + RPC_SEPARATOR_CHAR + // short
+    "9101112" + RPC_SEPARATOR_CHAR; // int
+    
+    RPC.decodeRequest(goodRequest); // should succeed
+    
+    // Create bad RPC messages with out of range, fractional, and non-numerical
+    // values for byte, char, short, and int fields.
+    for (int idx = 0; idx < 12; idx++) {
+      String b = "12";
+      String c = "345";
+      String s = "678";
+      String i = "9101112";
+      String message = null;
+      String badValue = null;
+      
+      // Choose type of bad value and expected error message string
+      switch (idx / 4) {
+        case 0:
+          badValue = "123456789123456789";
+          message = "out-of-range";
+          break;
+        case 1:
+          badValue = "1.25";
+          message = "fractional";
+          break;
+        case 2:
+          badValue = "123ABC";
+          message = "non-numerical";
+          break;
+      }
+      
+      // Choose field to hold bad value
+      switch (idx % 4) {
+        case 0: b = badValue; break;
+        case 1: c = badValue; break;
+        case 2: s = badValue; break;
+        case 3: i = badValue; break;
+      }
+      
+      // Form the request
+      String request = requestBase + b + RPC_SEPARATOR_CHAR + // byte
+          c + RPC_SEPARATOR_CHAR + // char
+          s + RPC_SEPARATOR_CHAR + // short
+          i + RPC_SEPARATOR_CHAR; // int
+      
+      // Check that request fails with the expected message
+      try {
+        RPC.decodeRequest(request);
+        fail();
+      } catch (IncompatibleRemoteServiceException e) {
+        assertTrue(e.getMessage().contains(message));
+      }
+    }
+  }
 
   /**
    * Tests that seeing obsolete RPC formats throws an