diff -r -U3 -p ocaml-3.11.0/byterun/int64_emul.h ocaml-3.11.0-lexing/byterun/int64_emul.h
--- ocaml-3.11.0/byterun/int64_emul.h	2005-09-22 10:21:50.000000000 -0400
+++ ocaml-3.11.0-lexing/byterun/int64_emul.h	2009-06-02 09:35:23.000000000 -0400
@@ -38,6 +38,7 @@ static int I64_ucompare(uint64 x, uint64
 }
 
 #define I64_ult(x, y) (I64_ucompare(x, y) < 0)
+#define I64_eq(x, y) (I64_ucompare(x, y) == 0)
 
 /* Signed comparison */
 static int I64_compare(int64 x, int64 y)
diff -r -U3 -p ocaml-3.11.0/byterun/int64_native.h ocaml-3.11.0-lexing/byterun/int64_native.h
--- ocaml-3.11.0/byterun/int64_native.h	2005-09-22 10:21:50.000000000 -0400
+++ ocaml-3.11.0-lexing/byterun/int64_native.h	2009-06-02 09:35:46.000000000 -0400
@@ -23,6 +23,7 @@
 #define I64_literal(hi,lo) ((int64)(hi) << 32 | (lo))
 #define I64_compare(x,y) (((x) > (y)) - ((x) < (y)))
 #define I64_ult(x,y) ((uint64)(x) < (uint64)(y))
+#define I64_eq(x,y) ((uint64)(x) == (uint64)(y))
 #define I64_neg(x) (-(x))
 #define I64_add(x,y) ((x) + (y))
 #define I64_sub(x,y) ((x) - (y))
diff -r -U3 -p ocaml-3.11.0/byterun/ints.c ocaml-3.11.0-lexing/byterun/ints.c
--- ocaml-3.11.0/byterun/ints.c	2008-01-11 11:13:16.000000000 -0500
+++ ocaml-3.11.0-lexing/byterun/ints.c	2009-06-02 10:50:35.000000000 -0400
@@ -58,7 +58,9 @@ static int parse_digit(char c)
     return -1;
 }
 
-static intnat parse_intnat(value s, int nbits)
+typedef enum { TIGHT, LOOSE } intnat_bound;
+
+static intnat parse_intnat(value s, int nbits, intnat_bound bound)
 {
   char * p;
   uintnat res, threshold;
@@ -83,8 +85,9 @@ static intnat parse_intnat(value s, int 
     caml_failwith("int_of_string");
   }
   if (base == 10) {
+    uintnat limit = (uintnat)1 << (nbits - 1);
     /* Signed representation expected, allow -2^(nbits-1) to 2^(nbits - 1) */
-    if (res > (uintnat)1 << (nbits - 1))
+    if (res > limit || (res == limit && sign >= 0 && bound == TIGHT))
       caml_failwith("int_of_string");
   } else {
     /* Unsigned representation expected, allow 0 to 2^nbits - 1
@@ -123,7 +126,12 @@ CAMLprim value caml_int_compare(value v1
 
 CAMLprim value caml_int_of_string(value s)
 {
-  return Val_long(parse_intnat(s, 8 * sizeof(value) - 1));
+  return Val_long(parse_intnat(s, 8 * sizeof(value) - 1, TIGHT));
+}
+
+CAMLprim value caml_lexer_int_of_string(value s)
+{
+  return Val_long(parse_intnat(s, 8 * sizeof(value) - 1, LOOSE));
 }
 
 #define FORMAT_BUFFER_SIZE 32
@@ -324,7 +332,12 @@ CAMLprim value caml_int32_format(value f
 
 CAMLprim value caml_int32_of_string(value s)
 {
-  return caml_copy_int32(parse_intnat(s, 32));
+  return caml_copy_int32(parse_intnat(s, 32, TIGHT));
+}
+
+CAMLprim value caml_lexer_int32_of_string(value s)
+{
+  return caml_copy_int32(parse_intnat(s, 32, LOOSE));
 }
 
 CAMLprim value caml_int32_bits_of_float(value vd)
@@ -517,7 +530,7 @@ CAMLprim value caml_int64_format(value f
   return res;
 }
 
-CAMLprim value caml_int64_of_string(value s)
+static value caml_internal_int64_of_string(value s, intnat_bound bound)
 {
   char * p;
   uint64 max_uint64 = I64_literal(0xFFFFFFFF, 0xFFFFFFFF);
@@ -544,11 +557,24 @@ CAMLprim value caml_int64_of_string(valu
   if (p != String_val(s) + caml_string_length(s)){
     caml_failwith("int_of_string");
   }
-  if (base == 10 && I64_ult(max_int64, res)) caml_failwith("int_of_string");
+  if (base == 10
+      && (I64_ult(max_int64, res)
+          || (I64_eq(max_int64, res) && sign >= 0 && bound == TIGHT)))
+    caml_failwith("int_of_string");
   if (sign < 0) res = I64_neg(res);
   return caml_copy_int64(res);
 }
 
+CAMLprim value caml_int64_of_string(value s)
+{
+  return caml_internal_int64_of_string(s, TIGHT);
+}
+
+CAMLprim value caml_lexer_int64_of_string(value s)
+{
+  return caml_internal_int64_of_string(s, LOOSE);
+}
+
 CAMLprim value caml_int64_bits_of_float(value vd)
 {
   union { double d; int64 i; int32 h[2]; } u;
@@ -734,5 +760,11 @@ CAMLprim value caml_nativeint_format(val
 
 CAMLprim value caml_nativeint_of_string(value s)
 {
-  return caml_copy_nativeint(parse_intnat(s, 8 * sizeof(value)));
+  return caml_copy_nativeint(parse_intnat(s, 8 * sizeof(value), TIGHT));
 }
+
+CAMLprim value caml_lexer_nativeint_of_string(value s)
+{
+  return caml_copy_nativeint(parse_intnat(s, 8 * sizeof(value), LOOSE));
+}
+
diff -r -U3 -p ocaml-3.11.0/parsing/lexer.mll ocaml-3.11.0-lexing/parsing/lexer.mll
--- ocaml-3.11.0/parsing/lexer.mll	2008-10-08 09:07:13.000000000 -0400
+++ ocaml-3.11.0-lexing/parsing/lexer.mll	2009-06-02 09:47:03.000000000 -0400
@@ -94,6 +94,14 @@ let keyword_table =
     "asr", INFIXOP4("asr")
 ]
 
+(* Parsing of integer literals *)
+
+external lexer_int_of_string : string -> int = "caml_lexer_int_of_string"
+external lexer_int32_of_string : string -> int32 = "caml_lexer_int32_of_string"
+external lexer_int64_of_string : string -> int64 = "caml_lexer_int64_of_string"
+external lexer_nativeint_of_string : string -> nativeint =
+  "caml_lexer_nativeint_of_string"
+
 (* To buffer string literals *)
 
 let initial_string_buffer = String.create 256
@@ -264,7 +272,7 @@ rule token = parse
       { UIDENT(Lexing.lexeme lexbuf) }       (* No capitalized keywords *)
   | int_literal
       { try
-          INT (int_of_string(Lexing.lexeme lexbuf))
+          INT (lexer_int_of_string(Lexing.lexeme lexbuf))
         with Failure _ ->
           raise (Error(Literal_overflow "int", Location.curr lexbuf))
       }
@@ -273,20 +281,20 @@ rule token = parse
   | int_literal "l"
       { let s = Lexing.lexeme lexbuf in
         try
-          INT32 (Int32.of_string(String.sub s 0 (String.length s - 1)))
+          INT32 (lexer_int32_of_string(String.sub s 0 (String.length s - 1)))
         with Failure _ ->
           raise (Error(Literal_overflow "int32", Location.curr lexbuf)) }
   | int_literal "L"
       { let s = Lexing.lexeme lexbuf in
         try
-          INT64 (Int64.of_string(String.sub s 0 (String.length s - 1)))
+          INT64 (lexer_int64_of_string(String.sub s 0 (String.length s - 1)))
         with Failure _ ->
           raise (Error(Literal_overflow "int64", Location.curr lexbuf)) }
   | int_literal "n"
       { let s = Lexing.lexeme lexbuf in
         try
           NATIVEINT
-            (Nativeint.of_string(String.sub s 0 (String.length s - 1)))
+            (lexer_nativeint_of_string(String.sub s 0 (String.length s - 1)))
         with Failure _ ->
           raise (Error(Literal_overflow "nativeint", Location.curr lexbuf)) }
   | "\""