diff --git a/Python/compile.c b/Python/compile.c
index b61658e..9567190 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -41,6 +41,8 @@
 
 #include <ctype.h>
 
+extern int errno;
+
 #define OFF(x) offsetof(codeobject, x)
 
 static struct memberlist code_memberlist[] = {
@@ -349,14 +351,28 @@
 	char *s;
 {
 	extern long strtol();
-	extern double atof();
+	extern double strtod();
 	char *end = s;
 	long x;
+	double xx;
+	errno = 0;
 	x = strtol(s, &end, 0);
-	if (*end == '\0')
+	if (*end == '\0') {
+		if (errno != 0) {
+			err_setstr(RuntimeError, "integer constant too large");
+			return NULL;
+		}
 		return newintobject(x);
-	if (*end == '.' || *end == 'e' || *end == 'E')
-		return newfloatobject(atof(s));
+	}
+	errno = 0;
+	xx = strtod(s, &end);
+	if (*end == '\0') {
+		if (errno != 0) {
+			err_setstr(RuntimeError, "float constant too large");
+			return NULL;
+		}
+		return newfloatobject(xx);
+	}
 	err_setstr(RuntimeError, "bad number syntax");
 	return NULL;
 }
@@ -1752,6 +1768,96 @@
 	}
 }
 
+/* Optimization for local and global variables.
+
+   Attempt to replace all LOAD_NAME instructions that refer to a local
+   variable with LOAD_LOCAL instructions, and all that refer to a global
+   variable with LOAD_GLOBAL instructions.
+   
+   To find all local variables, we check all STORE_NAME and IMPORT_FROM
+   instructions.  This yields all local variables, including arguments,
+   function definitions, class definitions and import statements.
+   
+   There is one leak: 'from foo import *' introduces local variables
+   that we can't know while compiling.  If this is the case, LOAD_GLOBAL
+   instructions are not generated -- LOAD_NAME is left in place for
+   globals, since it first checks for globals (LOAD_LOCAL is still used
+   for recognized locals, since it doesn't hurt).
+   
+   This optimization means that using the same name as a global and
+   as a local variable within the same scope is now illegal, which
+   is a change to the language!  Also using eval() to introduce new
+   local variables won't work.  But both were bad practice at best.
+   
+   The optimization doesn't save much: basically, it saves one
+   unsuccessful dictionary lookup per global (or built-in) variable
+   reference.  On the (slow!) Mac Plus, with 4 local variables,
+   this saving was measured to be about 0.18 ms.  We might save more
+   by using a different data structure to hold local variables, like
+   an array indexed by variable number.
+   
+   NB: this modifies the string object co->co_code!
+*/
+
+static void
+optimizer(co)
+	codeobject *co;
+{
+	char *next_instr, *cur_instr;
+	object *locals;
+	int opcode;
+	int oparg;
+	object *name;
+	int star_used;
+	
+#define NEXTOP()	(*next_instr++)
+#define NEXTARG()	(next_instr += 2, (next_instr[-1]<<8) + next_instr[-2])
+#define GETITEM(v, i)	(getlistitem((v), (i)))
+#define GETNAMEOBJ(i)	(GETITEM(co->co_names, (i)))
+
+	locals = newdictobject();
+	if (locals == NULL) {
+		err_clear();
+		return; /* For now, this is OK */
+	}
+	
+	next_instr = GETSTRINGVALUE(co->co_code); 
+	for (;;) {
+		opcode = NEXTOP();
+		if (opcode == STOP_CODE)
+			break;
+		if (HAS_ARG(opcode))
+			oparg = NEXTARG();
+		if (opcode == STORE_NAME || opcode == IMPORT_FROM) {
+			name = GETNAMEOBJ(oparg);
+			if (dict2insert(locals, name, None) != 0) {
+				DECREF(locals);
+				return; /* Sorry */
+			}
+		}
+	}
+	
+	star_used = (dictlookup(locals, "*") != NULL);
+	next_instr = GETSTRINGVALUE(co->co_code); 
+	for (;;) {
+		cur_instr = next_instr;
+		opcode = NEXTOP();
+		if (opcode == STOP_CODE)
+			break;
+		if (HAS_ARG(opcode))
+			oparg = NEXTARG();
+		if (opcode == LOAD_NAME) {
+			name = GETNAMEOBJ(oparg);
+			if (dictlookup(locals, getstringvalue(name)) != NULL)
+				*cur_instr = LOAD_LOCAL;
+			else if (!star_used)
+				*cur_instr = LOAD_GLOBAL;
+		}
+	}
+	
+	DECREF(locals);
+}
+
 codeobject *
 compile(n, filename)
 	node *n;
@@ -1768,5 +1874,7 @@
 	else
 		co = NULL;
 	com_free(&sc);
+	if (co != NULL)
+		optimizer(co);
 	return co;
 }