New branch for lexbind, losing all history.

This initial patch is based on 2002-06-27T22:39:10Z!storm@cua.dk of the original
lexbind branch.

14 files changed, 945 insertions, 90 deletions

diff --git a/src/ChangeLog.funvec b/src/ChangeLog.funvec
new file mode 100644
index 00000000000..098539f1dd9
--- /dev/null
+++ b/src/ChangeLog.funvec
@@ -0,0 +1,37 @@
+2004-05-20  Miles Bader  <miles@gnu.org>
+
+        * lisp.h: Declare make_funvec and Ffunvec.
+        (enum pvec_type): Rename `PVEC_COMPILED' to `PVEC_FUNVEC'.
+        (XSETFUNVEC): Renamed from `XSETCOMPILED'.
+        (FUNVEC_SIZE, FUNVEC_COMPILED_TAG_P, FUNVEC_COMPILED_P): New macros.
+        (COMPILEDP): Define in terms of funvec macros.
+        (FUNVECP, GC_FUNVECP): Renamed from `COMPILEDP' & `GC_COMPILEDP'.
+        (FUNCTIONP): Use FUNVECP instead of COMPILEDP.
+        * alloc.c (make_funvec, funvec): New functions.
+        (Fmake_byte_code): Make sure the first element is a list.
+
+        * eval.c (Qcurry): New variable.
+        (funcall_funvec, Fcurry): New functions.
+        (syms_of_eval): Initialize them.
+        (funcall_lambda): Handle non-bytecode funvec objects by calling
+        funcall_funvec.
+        (Ffuncall, Feval): Use FUNVECP insetad of COMPILEDP.
+        * lread.c (read1): Return result of read_vector for `#[' syntax
+        directly; read_vector now does any extra work required.
+        (read_vector): Handle both funvec and byte-code objects, converting the
+        type as necessary.  `bytecodeflag' argument is now called
+        `read_funvec'.
+        * data.c (Ffunvecp): New function.
+        * doc.c (Fdocumentation): Return nil for unknown funvecs.
+        * fns.c (mapcar1, Felt, concat): Allow funvecs.
+
+        * eval.c (Ffunctionp): Use `funvec' operators instead of `compiled'
+        operators.
+        * alloc.c (Fmake_byte_code, Fpurecopy, mark_object): Likewise.
+        * keyboard.c (Fcommand_execute): Likewise.
+        * image.c (parse_image_spec): Likewise.
+        * fns.c (Flength, concat, internal_equal): Likewise.
+        * data.c (Faref, Ftype_of): Likewise.
+        * print.c (print_preprocess, print_object): Likewise.
+
+;; arch-tag: f35a6a00-4a11-4739-a4b6-9cf98296f315
diff --git a/src/ChangeLog.lexbind b/src/ChangeLog.lexbind
new file mode 100644
index 00000000000..c8336d12e9c
--- /dev/null
+++ b/src/ChangeLog.lexbind
@@ -0,0 +1,104 @@
+2008-04-23  Miles Bader  <miles@gnu.org>
+
+        * eval.c (Ffunctionp): Return nil for special forms.
+        (Qunevalled): New variable.
+        (syms_of_eval): Initialize it.
+
+2007-10-18  Miles Bader  <miles@gnu.org>
+
+        * eval.c (FletX): Test the type of VARLIST rather than just !NILP.
+        (Flet): Use XCAR instead of Fcar.
+
+2007-10-16  Miles Bader  <miles@gnu.org>
+
+        * alloc.c (make_funvec, Fpurecopy): Set the pseudo-vector type.
+
+2006-02-10  Miles Bader  <miles@gnu.org>
+
+        * eval.c (Ffunctionp): Supply new 2nd arg to Findirect_function.
+
+2005-03-04  Miles Bader  <miles@gnu.org>
+
+        * eval.c (FletX): Update Vinterpreter_lexical_environment for each
+        variable we bind, instead of all at once like `let'.
+
+2004-08-09  Miles Bader  <miles@gnu.org>
+
+        Changes from merging the funvec patch:
+        
+        * eval.c (Feval, Ffuncall): Don't special-case vectors.
+        (funcall_lambda): Use FUNVEC_SIZE.
+        (Fcurry): Remove function.
+
+        Merge funvec patch.
+
+2004-04-10  Miles Bader  <miles@gnu.org>
+
+        * eval.c (Fspecialp): New function.
+        (syms_of_eval): Initialize it.
+
+2004-04-03  Miles Bader  <miles@gnu.org>
+
+        * eval.c (Feval): If a variable isn't bound lexically, fall back
+        to looking it up dynamically even if it isn't declared special.
+
+2002-08-26  Miles Bader  <miles@gnu.org>
+
+        * bytecode.c (Fbyte_code): Fsub1 can GC, so protect it.
+
+2002-06-12  Miles Bader  <miles@gnu.org>
+
+        Lexical binding changes to the byte-code interpreter:
+
+        * bytecode.c (Bstack_ref, Bstack_set, Bstack_set2, Bvec_ref, Bvec_set)
+        (BdiscardN): New constants. 
+        (exec_byte_code): Renamed from `Fbyte_code'.
+        Implement above new bytecodes.
+        Add ARGS-TEMPLATE, NARGS and ARGS parameters, and optionally use
+        them push initial args on the stack.
+        (Fbyte_code): New function, just call `exec_byte_code'.
+        Add additional optional arguments for `exec_byte_code'.
+        (Qand_optional, Qand_rest): New extern declarations.
+        * eval.c (Fcurry, Ffunctionp): New functions.
+        (syms_of_eval): Initialize them.
+        (funcall_lambda): Call `exec_byte_code' instead of Fbyte_code.
+        If a compiled-function object has a `push-args' slot, call the
+        byte-code interpreter without binding any arguments.
+        (Ffuncall): Add support for curried functions.
+        * lisp.h (Fbyte_code): Declare max-args as MANY.
+        (exec_byte_code): New declaration.
+
+        Lexical binding changes to the lisp interpreter:
+
+        * lisp.h (struct Lisp_Symbol): Add `declared_special' field.
+        (apply_lambda): Add new 3rd arg to decl.
+        * alloc.c (Fmake_symbol): Initialize `declared_special' field.
+        * eval.c (Vinterpreter_lexical_environment): New variable.
+        (syms_of_eval): Initialize it.
+        (Fsetq): Modify SYM's lexical binding if appropriate.
+        (Ffunction): Return a closure if within a lexical environment.
+        (Flet, FletX): Lexically bind non-defvar'd variables if inside a
+        lexical environment.
+        (Feval): Return lexical binding of variables, if they have one.
+        Pass current lexical environment to embedded lambdas.  Handle closures.
+        (Ffuncall): Pass nil lexical environment to lambdas.  Handle closures.
+        (funcall_lambda): Add new LEXENV argument, and lexically bind
+        arguments if it's non-nil.  Bind `interpreter-lexenv' if it changed.
+        (apply_lambda): Add new LEXENV argument and pass it to funcall_lambda.
+        (Fdefvaralias, Fdefvar, Fdefconst): Mark the variable as special.
+        (Qinternal_interpreter_environment, Qclosure): New constants.
+        (syms_of_eval): Initialize them.
+        (Fdefun, Fdefmacro): Use a closure if lexical binding is active.
+        * lread.c (defvar_bool, defvar_lisp_nopro, defvar_per_buffer) 
+        (defvar_kboard, defvar_int): Mark the variable as special.
+        (Vlexical_binding, Qlexical_binding): New variables.
+        (syms_of_lread): Initialize them.
+        (Fload): Bind `lexically-bound' to nil unless specified otherwise
+        in the file header.
+        (lisp_file_lexically_bound_p): New function.
+        (Qinternal_interpreter_environment): New variable.
+        * doc.c (Qclosure): New extern declaration.
+        (Fdocumentation, store_function_docstring): Handle interpreted
+        closures.
+
+;; arch-tag: 7cf884aa-6b48-40cb-bfca-265a1e99b3c5
diff --git a/src/alloc.c b/src/alloc.c
index e0f07cc5f5a..a23c688043c 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -3042,6 +3042,39 @@ See also the function `vector'.  */)
 }
 
 
+/* Return a new `function vector' containing KIND as the first element,
+   followed by NUM_NIL_SLOTS nil elements, and further elements copied from
+   the vector PARAMS of length NUM_PARAMS (so the total length of the
+   resulting vector is 1 + NUM_NIL_SLOTS + NUM_PARAMS).
+
+   If NUM_PARAMS is zero, then PARAMS may be NULL.
+
+   A `function vector', a.k.a. `funvec', is a funcallable vector in Emacs Lisp.
+   See the function `funvec' for more detail.  */
+
+Lisp_Object
+make_funvec (kind, num_nil_slots, num_params, params)
+     Lisp_Object kind;
+     int num_nil_slots, num_params;
+     Lisp_Object *params;
+{
+  int param_index;
+  Lisp_Object funvec;
+
+  funvec = Fmake_vector (make_number (1 + num_nil_slots + num_params), Qnil);
+
+  ASET (funvec, 0, kind);
+
+  for (param_index = 0; param_index < num_params; param_index++)
+    ASET (funvec, 1 + num_nil_slots + param_index, params[param_index]);
+
+  XSETPVECTYPE (XVECTOR (funvec), PVEC_FUNVEC);
+  XSETFUNVEC (funvec, XVECTOR (funvec));
+
+  return funvec;
+}
+
+
 DEFUN ("vector", Fvector, Svector, 0, MANY, 0,
        doc: /* Return a newly created vector with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
@@ -3063,6 +3096,29 @@ usage: (vector &rest OBJECTS)  */)
 }
 
 
+DEFUN ("funvec", Ffunvec, Sfunvec, 1, MANY, 0,
+       doc: /* Return a newly created `function vector' of type KIND.
+A `function vector', a.k.a. `funvec', is a funcallable vector in Emacs Lisp.
+KIND indicates the kind of funvec, and determines its behavior when called.
+The meaning of the remaining arguments depends on KIND.  Currently
+implemented values of KIND, and their meaning, are:
+
+   A list  -- A byte-compiled function.  See `make-byte-code' for the usual
+              way to create byte-compiled functions.
+
+   `curry' -- A curried function.  Remaining arguments are a function to
+              call, and arguments to prepend to user arguments at the
+              time of the call; see the `curry' function.
+
+usage: (funvec KIND &rest PARAMS)  */)
+     (nargs, args)
+     register int nargs;
+     Lisp_Object *args;
+{
+  return make_funvec (args[0], 0, nargs - 1, args + 1);
+}
+
+
 DEFUN ("make-byte-code", Fmake_byte_code, Smake_byte_code, 4, MANY, 0,
        doc: /* Create a byte-code object with specified arguments as elements.
 The arguments should be the arglist, bytecode-string, constant vector,
@@ -3078,6 +3134,10 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
   register int index;
   register struct Lisp_Vector *p;
 
+  /* Make sure the arg-list is really a list, as that's what's used to
+     distinguish a byte-compiled object from other funvecs.  */
+  CHECK_LIST (args[0]);
+
   XSETFASTINT (len, nargs);
   if (!NILP (Vpurify_flag))
     val = make_pure_vector ((EMACS_INT) nargs);
@@ -3099,8 +3159,8 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
         args[index] = Fpurecopy (args[index]);
       p->contents[index] = args[index];
     }
-  XSETPVECTYPE (p, PVEC_COMPILED);
-  XSETCOMPILED (val, p);
+  XSETPVECTYPE (p, PVEC_FUNVEC);
+  XSETFUNVEC (val, p);
   return val;
 }
 
@@ -3199,6 +3259,7 @@ Its value and function definition are void, and its property list is nil.  */)
   p->gcmarkbit = 0;
   p->interned = SYMBOL_UNINTERNED;
   p->constant = 0;
+  p->declared_special = 0;
   consing_since_gc += sizeof (struct Lisp_Symbol);
   symbols_consed++;
   return val;
@@ -4907,7 +4968,7 @@ Does not copy symbols.  Copies strings without text properties.  */)
     obj = make_pure_string (SDATA (obj), SCHARS (obj),
                             SBYTES (obj),
                             STRING_MULTIBYTE (obj));
-  else if (COMPILEDP (obj) || VECTORP (obj))
+  else if (FUNVECP (obj) || VECTORP (obj))
     {
       register struct Lisp_Vector *vec;
       register int i;
@@ -4919,10 +4980,10 @@ Does not copy symbols.  Copies strings without text properties.  */)
       vec = XVECTOR (make_pure_vector (size));
       for (i = 0; i < size; i++)
         vec->contents[i] = Fpurecopy (XVECTOR (obj)->contents[i]);
-      if (COMPILEDP (obj))
+      if (FUNVECP (obj))
         {
-          XSETPVECTYPE (vec, PVEC_COMPILED);
-          XSETCOMPILED (obj, vec);
+          XSETPVECTYPE (vec, PVEC_FUNVEC);
+          XSETFUNVEC (obj, vec);
         }
       else
         XSETVECTOR (obj, vec);
@@ -5512,7 +5573,7 @@ mark_object (arg)
         }
       else if (SUBRP (obj))
         break;
-      else if (COMPILEDP (obj))
+      else if (FUNVECP (obj) && FUNVEC_COMPILED_P (obj))
         /* We could treat this just like a vector, but it is better to
            save the COMPILED_CONSTANTS element for last and avoid
            recursion there.  */
@@ -6423,6 +6484,7 @@ The time is in seconds as a floating point value.  */);
   defsubr (&Scons);
   defsubr (&Slist);
   defsubr (&Svector);
+  defsubr (&Sfunvec);
   defsubr (&Smake_byte_code);
   defsubr (&Smake_list);
   defsubr (&Smake_vector);
diff --git a/src/buffer.c b/src/buffer.c
index 589266f40e5..e907c295e8d 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5418,6 +5418,7 @@ defvar_per_buffer (bo_fwd, namestring, address, type, doc)
   bo_fwd->type = Lisp_Fwd_Buffer_Obj;
   bo_fwd->offset = offset;
   bo_fwd->slottype = type;
+  sym->declared_special = 1;
   sym->redirect = SYMBOL_FORWARDED;
   {
     /* I tried to do the job without a cast, but it seems impossible.
diff --git a/src/bytecode.c b/src/bytecode.c
index c53c5acdbb3..fec855c0b83 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -87,9 +87,11 @@ int byte_metering_on;
 
 
 Lisp_Object Qbytecode;
+extern Lisp_Object Qand_optional, Qand_rest;
 
 /*  Byte codes: */
 
+#define Bstack_ref 0
 #define Bvarref 010
 #define Bvarset 020
 #define Bvarbind 030
@@ -229,6 +231,13 @@ Lisp_Object Qbytecode;
 #define BconcatN 0260
 #define BinsertN 0261
 
+/* Bstack_ref is code 0.  */
+#define Bstack_set  0262
+#define Bstack_set2 0263
+#define Bvec_ref    0264
+#define Bvec_set    0265
+#define BdiscardN   0266
+
 #define Bconstant 0300
 #define CONSTANTLIM 0100
 
@@ -397,14 +406,41 @@ unmark_byte_stack ()
   } while (0)
 
 
-DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, 3, 0,
+DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, MANY, 0,
        doc: /* Function used internally in byte-compiled code.
 The first argument, BYTESTR, is a string of byte code;
 the second, VECTOR, a vector of constants;
 the third, MAXDEPTH, the maximum stack depth used in this function.
-If the third argument is incorrect, Emacs may crash.  */)
-     (bytestr, vector, maxdepth)
-     Lisp_Object bytestr, vector, maxdepth;
+If the third argument is incorrect, Emacs may crash.
+
+If ARGS-TEMPLATE is specified, it is an argument list specification,
+according to which any remaining arguments are pushed on the stack
+before executing BYTESTR.
+
+usage: (byte-code BYTESTR VECTOR MAXDEP &optional ARGS-TEMPLATE &rest ARGS) */)
+     (nargs, args)
+     int nargs;
+     Lisp_Object *args;
+{
+  Lisp_Object args_tmpl = nargs >= 4 ? args[3] : Qnil;
+  int pnargs = nargs >= 4 ? nargs - 4 : 0;
+  Lisp_Object *pargs = nargs >= 4 ? args + 4 : 0;
+  return exec_byte_code (args[0], args[1], args[2], args_tmpl, pnargs, pargs);
+}
+
+/* Execute the byte-code in BYTESTR.  VECTOR is the constant vector, and
+   MAXDEPTH is the maximum stack depth used (if MAXDEPTH is incorrect,
+   emacs may crash!).  If ARGS_TEMPLATE is non-nil, it should be a lisp
+   argument list (including &rest, &optional, etc.), and ARGS, of size
+   NARGS, should be a vector of the actual arguments.  The arguments in
+   ARGS are pushed on the stack according to ARGS_TEMPLATE before
+   executing BYTESTR.  */
+
+Lisp_Object
+exec_byte_code (bytestr, vector, maxdepth, args_template, nargs, args)
+     Lisp_Object bytestr, vector, maxdepth, args_template;
+     int nargs;
+     Lisp_Object *args;
 {
   int count = SPECPDL_INDEX ();
 #ifdef BYTE_CODE_METER
@@ -462,6 +498,37 @@ If the third argument is incorrect, Emacs may crash.  */)
   stacke = stack.bottom - 1 + XFASTINT (maxdepth);
 #endif
 
+  if (! NILP (args_template))
+    /* We should push some arguments on the stack.  */
+    {
+      Lisp_Object at;
+      int pushed = 0, optional = 0;
+
+      for (at = args_template; CONSP (at); at = XCDR (at))
+        if (EQ (XCAR (at), Qand_optional))
+          optional = 1;
+        else if (EQ (XCAR (at), Qand_rest))
+          {
+            PUSH (Flist (nargs, args));
+            pushed = nargs;
+            at = Qnil;
+            break;
+          }
+        else if (pushed < nargs)
+          {
+            PUSH (*args++);
+            pushed++;
+          }
+        else if (optional)
+          PUSH (Qnil);
+        else
+          break;
+
+      if (pushed != nargs || !NILP (at))
+        Fsignal (Qwrong_number_of_arguments,
+                 Fcons (args_template, Fcons (make_number (nargs), Qnil)));
+    }
+
   while (1)
     {
 #ifdef BYTE_CODE_SAFE
@@ -1641,8 +1708,57 @@ If the third argument is incorrect, Emacs may crash.  */)
           break;
 #endif
 
-        case 0:
-          abort ();
+          /* Handy byte-codes for lexical binding.  */
+        case Bstack_ref:
+        case Bstack_ref+1:
+        case Bstack_ref+2:
+        case Bstack_ref+3:
+        case Bstack_ref+4:
+        case Bstack_ref+5:
+          PUSH (stack.bottom[op - Bstack_ref]);
+          break;
+        case Bstack_ref+6:
+          PUSH (stack.bottom[FETCH]);
+          break;
+        case Bstack_ref+7:
+          PUSH (stack.bottom[FETCH2]);
+          break;
+        case Bstack_set:
+          stack.bottom[FETCH] = POP;
+          break;
+        case Bstack_set2:
+          stack.bottom[FETCH2] = POP;
+          break;
+        case Bvec_ref:
+        case Bvec_set:
+          /* These byte-codes used mostly for variable references to
+             lexically bound variables that are in an environment vector
+             instead of on the byte-interpreter stack (generally those
+             variables which might be shared with a closure).  */
+          {
+            int index = FETCH;
+            Lisp_Object vec = POP;
+
+            if (! VECTORP (vec))
+              wrong_type_argument (Qvectorp, vec);
+            else if (index < 0 || index >= XVECTOR (vec)->size)
+              args_out_of_range (vec, index);
+
+            if (op == Bvec_ref)
+              PUSH (XVECTOR (vec)->contents[index]);
+            else
+              XVECTOR (vec)->contents[index] = POP;
+          }
+          break;
+        case BdiscardN:
+          op = FETCH;
+          if (op & 0x80)
+            {
+              op &= 0x7F;
+              top[-op] = TOP;
+            }
+          DISCARD (op);
+          break;
 
         case 255:
         default:
diff --git a/src/data.c b/src/data.c
index 93cc57e9f2c..6a21ad44720 100644
--- a/src/data.c
+++ b/src/data.c
@@ -84,7 +84,7 @@ Lisp_Object Qinteger;
 static Lisp_Object Qsymbol, Qstring, Qcons, Qmarker, Qoverlay;
 static Lisp_Object Qfloat, Qwindow_configuration, Qwindow;
 Lisp_Object Qprocess;
-static Lisp_Object Qcompiled_function, Qbuffer, Qframe, Qvector;
+static Lisp_Object Qcompiled_function, Qfunction_vector, Qbuffer, Qframe, Qvector;
 static Lisp_Object Qchar_table, Qbool_vector, Qhash_table;
 static Lisp_Object Qsubrp, Qmany, Qunevalled;
 Lisp_Object Qfont_spec, Qfont_entity, Qfont_object;
@@ -219,8 +219,11 @@ for example, (type-of 1) returns `integer'.  */)
         return Qwindow;
       if (SUBRP (object))
         return Qsubr;
-      if (COMPILEDP (object))
-        return Qcompiled_function;
+      if (FUNVECP (object))
+        if (FUNVEC_COMPILED_P (object))
+          return Qcompiled_function;
+        else
+          return Qfunction_vector;
       if (BUFFERP (object))
         return Qbuffer;
       if (CHAR_TABLE_P (object))
@@ -437,6 +440,14 @@ DEFUN ("byte-code-function-p", Fbyte_code_function_p, Sbyte_code_function_p,
   return Qnil;
 }
 
+DEFUN ("funvecp", Ffunvecp, Sfunvecp, 1, 1, 0,
+       doc: /* Return t if OBJECT is a `function vector' object.  */)
+     (object)
+     Lisp_Object object;
+{
+  return FUNVECP (object) ? Qt : Qnil;
+}
+
 DEFUN ("char-or-string-p", Fchar_or_string_p, Schar_or_string_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a character or a string.  */)
      (object)
@@ -2208,15 +2219,15 @@ or a byte-code object.  IDX starts at 0.  */)
     {
       int size = 0;
       if (VECTORP (array))
-        size = XVECTOR (array)->size;
-      else if (COMPILEDP (array))
-        size = XVECTOR (array)->size & PSEUDOVECTOR_SIZE_MASK;
+        size = ASIZE (array);
+      else if (FUNVECP (array))
+        size = FUNVEC_SIZE (array);
       else
         wrong_type_argument (Qarrayp, array);
 
       if (idxval < 0 || idxval >= size)
         args_out_of_range (array, idx);
-      return XVECTOR (array)->contents[idxval];
+      return AREF (array, idxval);
     }
 }
 
@@ -3326,6 +3337,7 @@ syms_of_data ()
   Qwindow = intern_c_string ("window");
   /* Qsubr = intern_c_string ("subr"); */
   Qcompiled_function = intern_c_string ("compiled-function");
+  Qfunction_vector = intern_c_string ("function-vector");
   Qbuffer = intern_c_string ("buffer");
   Qframe = intern_c_string ("frame");
   Qvector = intern_c_string ("vector");
@@ -3351,6 +3363,7 @@ syms_of_data ()
   staticpro (&Qwindow);
   /* staticpro (&Qsubr); */
   staticpro (&Qcompiled_function);
+  staticpro (&Qfunction_vector);
   staticpro (&Qbuffer);
   staticpro (&Qframe);
   staticpro (&Qvector);
@@ -3387,6 +3400,7 @@ syms_of_data ()
   defsubr (&Smarkerp);
   defsubr (&Ssubrp);
   defsubr (&Sbyte_code_function_p);
+  defsubr (&Sfunvecp);
   defsubr (&Schar_or_string_p);
   defsubr (&Scar);
   defsubr (&Scdr);
diff --git a/src/doc.c b/src/doc.c
index 536d22c57a6..9133c2e6b84 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -56,7 +56,7 @@ Lisp_Object Qfunction_documentation;
 /* A list of files used to build this Emacs binary.  */
 static Lisp_Object Vbuild_files;
 
-extern Lisp_Object Voverriding_local_map;
+extern Lisp_Object Voverriding_local_map, Qclosure;
 
 extern Lisp_Object Qremap;
 
@@ -385,6 +385,11 @@ string is passed through `substitute-command-keys'.  */)
       else
         return Qnil;
     }
+  else if (FUNVECP (fun))
+    {
+      /* Unless otherwise handled, funvecs have no documentation.  */
+      return Qnil;
+    }
   else if (STRINGP (fun) || VECTORP (fun))
     {
       return build_string ("Keyboard macro.");
@@ -412,6 +417,8 @@ string is passed through `substitute-command-keys'.  */)
           else
             return Qnil;
         }
+      else if (EQ (funcar, Qclosure))
+        return Fdocumentation (Fcdr (XCDR (fun)), raw);
       else if (EQ (funcar, Qmacro))
         return Fdocumentation (Fcdr (fun), raw);
       else
@@ -542,6 +549,8 @@ store_function_docstring (fun, offset)
         }
       else if (EQ (tem, Qmacro))
         store_function_docstring (XCDR (fun), offset);
+      else if (EQ (tem, Qclosure))
+        store_function_docstring (Fcdr (XCDR (fun)), offset);
     }
 
   /* Bytecode objects sometimes have slots for it.  */
diff --git a/src/eval.c b/src/eval.c
index 199c4705736..875b4498a61 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -62,6 +62,9 @@ Lisp_Object Qinhibit_quit, Vinhibit_quit, Vquit_flag;
 Lisp_Object Qand_rest, Qand_optional;
 Lisp_Object Qdebug_on_error;
 Lisp_Object Qdeclare;
+Lisp_Object Qcurry, Qunevalled;
+Lisp_Object Qinternal_interpreter_environment, Qclosure;
+
 Lisp_Object Qdebug;
 extern Lisp_Object Qinteractive_form;
 
@@ -78,6 +81,13 @@ Lisp_Object Vrun_hooks;
 
 Lisp_Object Vautoload_queue;
 
+/* When lexical binding is being used, this is non-nil, and contains an
+   alist of lexically-bound variable, or t, indicating an empty
+   environment.  The lisp name of this variable is
+   `internal-interpreter-lexical-environment'.  */
+
+Lisp_Object Vinternal_interpreter_environment;
+
 /* Current number of specbindings allocated in specpdl.  */
 
 int specpdl_size;
@@ -167,10 +177,11 @@ int handling_signal;
 Lisp_Object Vmacro_declaration_function;
 
 extern Lisp_Object Qrisky_local_variable;
-
 extern Lisp_Object Qfunction;
 
-static Lisp_Object funcall_lambda P_ ((Lisp_Object, int, Lisp_Object*));
+static Lisp_Object funcall_lambda P_ ((Lisp_Object, int, Lisp_Object *,
+                                       Lisp_Object));
+
 static void unwind_to_catch P_ ((struct catchtag *, Lisp_Object)) NO_RETURN;
 
 #if __GNUC__
@@ -504,7 +515,7 @@ usage: (setq [SYM VAL]...)  */)
      Lisp_Object args;
 {
   register Lisp_Object args_left;
-  register Lisp_Object val, sym;
+  register Lisp_Object val, sym, lex_binding;
   struct gcpro gcpro1;
 
   if (NILP (args))
@@ -517,7 +528,15 @@ usage: (setq [SYM VAL]...)  */)
     {
       val = Feval (Fcar (Fcdr (args_left)));
       sym = Fcar (args_left);
-      Fset (sym, val);
+
+      if (!NILP (Vinternal_interpreter_environment)
+          && SYMBOLP (sym)
+          && !XSYMBOL (sym)->declared_special
+          && !NILP (lex_binding = Fassq (sym, Vinternal_interpreter_environment)))
+        XSETCDR (lex_binding, val); /* SYM is lexically bound.  */
+      else
+        Fset (sym, val);        /* SYM is dynamically bound.  */
+
       args_left = Fcdr (Fcdr (args_left));
     }
   while (!NILP(args_left));
@@ -545,9 +564,20 @@ usage: (function ARG)  */)
      (args)
      Lisp_Object args;
 {
+  Lisp_Object quoted = XCAR (args);
+
   if (!NILP (Fcdr (args)))
     xsignal2 (Qwrong_number_of_arguments, Qfunction, Flength (args));
-  return Fcar (args);
+
+  if (!NILP (Vinternal_interpreter_environment)
+      && CONSP (quoted)
+      && EQ (XCAR (quoted), Qlambda))
+    /* This is a lambda expression within a lexical environment;
+       return an interpreted closure instead of a simple lambda.  */
+    return Fcons (Qclosure, Fcons (Vinternal_interpreter_environment, quoted));
+  else
+    /* Simply quote the argument.  */
+    return quoted;
 }
 
 
@@ -570,7 +600,7 @@ spec that specifies non-nil unconditionally (such as \"p\"); or (ii)
 use `called-interactively-p'.  */)
      ()
 {
-  return (INTERACTIVE && interactive_p (1)) ? Qt : Qnil;
+  return interactive_p (1) ? Qt : Qnil;
 }
 
 
@@ -666,6 +696,8 @@ usage: (defun NAME ARGLIST [DOCSTRING] BODY...)  */)
   fn_name = Fcar (args);
   CHECK_SYMBOL (fn_name);
   defn = Fcons (Qlambda, Fcdr (args));
+  if (! NILP (Vinternal_interpreter_environment))
+    defn = Fcons (Qclosure, Fcons (Vinternal_interpreter_environment, defn));
   if (!NILP (Vpurify_flag))
     defn = Fpurecopy (defn);
   if (CONSP (XSYMBOL (fn_name)->function)
@@ -738,7 +770,11 @@ usage: (defmacro NAME ARGLIST [DOCSTRING] [DECL] BODY...)  */)
     tail = Fcons (lambda_list, tail);
   else
     tail = Fcons (lambda_list, Fcons (doc, tail));
-  defn = Fcons (Qmacro, Fcons (Qlambda, tail));
+  
+  defn = Fcons (Qlambda, tail);
+  if (! NILP (Vinternal_interpreter_environment))
+    defn = Fcons (Qclosure, Fcons (Vinternal_interpreter_environment, defn));
+  defn = Fcons (Qmacro, defn);
 
   if (!NILP (Vpurify_flag))
     defn = Fpurecopy (defn);
@@ -799,6 +835,7 @@ The return value is BASE-VARIABLE.  */)
         error ("Don't know how to make a let-bound variable an alias");
   }
 
+  sym->declared_special = 1;
   sym->redirect = SYMBOL_VARALIAS;
   SET_SYMBOL_ALIAS (sym, XSYMBOL (base_variable));
   sym->constant = SYMBOL_CONSTANT_P (base_variable);
@@ -889,6 +926,9 @@ usage: (defvar SYMBOL &optional INITVALUE DOCSTRING)  */)
        It could get in the way of other definitions, and unloading this
        package could try to make the variable unbound.  */
     ;
+    
+  if (SYMBOLP (sym))
+    XSYMBOL (sym)->declared_special = 1;
 
   return sym;
 }
@@ -918,6 +958,7 @@ usage: (defconst SYMBOL INITVALUE [DOCSTRING])  */)
   if (!NILP (Vpurify_flag))
     tem = Fpurecopy (tem);
   Fset_default (sym, tem);
+  XSYMBOL (sym)->declared_special = 1;
   tem = Fcar (Fcdr (Fcdr (args)));
   if (!NILP (tem))
     {
@@ -1006,30 +1047,50 @@ usage: (let* VARLIST BODY...)  */)
      (args)
      Lisp_Object args;
 {
-  Lisp_Object varlist, val, elt;
+  Lisp_Object varlist, var, val, elt, lexenv;
   int count = SPECPDL_INDEX ();
   struct gcpro gcpro1, gcpro2, gcpro3;
 
   GCPRO3 (args, elt, varlist);
 
+  lexenv = Vinternal_interpreter_environment;
+
   varlist = Fcar (args);
-  while (!NILP (varlist))
+  while (CONSP (varlist))
     {
       QUIT;
-      elt = Fcar (varlist);
+
+      elt = XCAR (varlist);
       if (SYMBOLP (elt))
-        specbind (elt, Qnil);
+        {
+          var = elt;
+          val = Qnil;
+        }
       else if (! NILP (Fcdr (Fcdr (elt))))
         signal_error ("`let' bindings can have only one value-form", elt);
       else
         {
+          var = Fcar (elt);
           val = Feval (Fcar (Fcdr (elt)));
-          specbind (Fcar (elt), val);
         }
-      varlist = Fcdr (varlist);
+
+      if (!NILP (lexenv) && SYMBOLP (var) && !XSYMBOL (var)->declared_special)
+        /* Lexically bind VAR by adding it to the interpreter's binding
+           alist.  */
+        {
+          lexenv = Fcons (Fcons (var, val), lexenv);
+          specbind (Qinternal_interpreter_environment, lexenv);
+        }
+      else
+        specbind (var, val);
+
+      varlist = XCDR (varlist);
     }
+
   UNGCPRO;
+
   val = Fprogn (Fcdr (args));
+
   return unbind_to (count, val);
 }
 
@@ -1043,7 +1104,7 @@ usage: (let VARLIST BODY...)  */)
      (args)
      Lisp_Object args;
 {
-  Lisp_Object *temps, tem;
+  Lisp_Object *temps, tem, lexenv;
   register Lisp_Object elt, varlist;
   int count = SPECPDL_INDEX ();
   register int argnum;
@@ -1074,18 +1135,31 @@ usage: (let VARLIST BODY...)  */)
     }
   UNGCPRO;
 
+  lexenv = Vinternal_interpreter_environment;
+
   varlist = Fcar (args);
   for (argnum = 0; CONSP (varlist); varlist = XCDR (varlist))
     {
+      Lisp_Object var;
+
       elt = XCAR (varlist);
+      var = SYMBOLP (elt) ? elt : Fcar (elt);
       tem = temps[argnum++];
-      if (SYMBOLP (elt))
-        specbind (elt, tem);
+
+      if (!NILP (lexenv) && SYMBOLP (var) && !XSYMBOL (var)->declared_special)
+        /* Lexically bind VAR by adding it to the lexenv alist.  */
+        lexenv = Fcons (Fcons (var, tem), lexenv);
       else
-        specbind (Fcar (elt), tem);
+        /* Dynamically bind VAR.  */
+        specbind (var, tem);
     }
 
+  if (!EQ (lexenv, Vinternal_interpreter_environment))
+    /* Instantiate a new lexical environment.  */
+    specbind (Qinternal_interpreter_environment, lexenv);
+
   elt = Fprogn (Fcdr (args));
+
   return unbind_to (count, elt);
 }
 
@@ -2292,7 +2366,28 @@ DEFUN ("eval", Feval, Seval, 1, 1, 0,
     abort ();
 
   if (SYMBOLP (form))
-    return Fsymbol_value (form);
+    {
+      /* If there's an active lexical environment, and the variable
+         isn't declared special, look up its binding in the lexical
+         environment.  */
+      if (!NILP (Vinternal_interpreter_environment)
+          && !XSYMBOL (form)->declared_special)
+        {
+          Lisp_Object lex_binding
+            = Fassq (form, Vinternal_interpreter_environment);
+
+          /* If we found a lexical binding for FORM, return the value.
+             Otherwise, we just drop through and look for a dynamic
+             binding -- the variable isn't declared special, but there's
+             not much else we can do, and Fsymbol_value will take care
+             of signaling an error if there is no binding at all.  */
+          if (CONSP (lex_binding))
+            return XCDR (lex_binding);
+        }
+      
+      return Fsymbol_value (form);
+    }
+
   if (!CONSP (form))
     return form;
 
@@ -2452,8 +2547,8 @@ DEFUN ("eval", Feval, Seval, 1, 1, 0,
           abort ();
         }
     }
-  if (COMPILEDP (fun))
-    val = apply_lambda (fun, original_args, 1);
+  if (FUNVECP (fun))
+    val = apply_lambda (fun, original_args, 1, Qnil);
   else
     {
       if (EQ (fun, Qunbound))
@@ -2471,7 +2566,18 @@ DEFUN ("eval", Feval, Seval, 1, 1, 0,
       if (EQ (funcar, Qmacro))
         val = Feval (apply1 (Fcdr (fun), original_args));
       else if (EQ (funcar, Qlambda))
-        val = apply_lambda (fun, original_args, 1);
+        val = apply_lambda (fun, original_args, 1,
+                            /* Only pass down the current lexical environment
+                               if FUN is lexically embedded in FORM.  */
+                            (CONSP (original_fun)
+                             ? Vinternal_interpreter_environment
+                             : Qnil));
+      else if (EQ (funcar, Qclosure)
+               && CONSP (XCDR (fun))
+               && CONSP (XCDR (XCDR (fun)))
+               && EQ (XCAR (XCDR (XCDR (fun))), Qlambda))
+        val = apply_lambda (XCDR (XCDR (fun)), original_args, 1,
+                            XCAR (XCDR (fun)));
       else
         xsignal1 (Qinvalid_function, original_fun);
     }
@@ -2981,6 +3087,40 @@ call7 (fn, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
 
 /* The caller should GCPRO all the elements of ARGS.  */
 
+DEFUN ("functionp", Ffunctionp, Sfunctionp, 1, 1, 0,
+       doc: /* Return non-nil if OBJECT is a type of object that can be called as a function.  */)
+     (object)
+     Lisp_Object object;
+{
+  if (SYMBOLP (object) && !NILP (Ffboundp (object)))
+    {
+      object = Findirect_function (object, Qnil);
+
+      if (CONSP (object) && EQ (XCAR (object), Qautoload))
+        {
+          /* Autoloaded symbols are functions, except if they load
+             macros or keymaps.  */
+          int i;
+          for (i = 0; i < 4 && CONSP (object); i++)
+            object = XCDR (object);
+
+          return (CONSP (object) && !NILP (XCAR (object))) ? Qnil : Qt;
+        }
+    }
+
+  if (SUBRP (object))
+    return (XSUBR (object)->max_args != Qunevalled) ? Qt : Qnil;
+  else if (FUNVECP (object))
+    return Qt;
+  else if (CONSP (object))
+    {
+      Lisp_Object car = XCAR (object);
+      return (EQ (car, Qlambda) || EQ (car, Qclosure)) ? Qt : Qnil;
+    }
+  else
+    return Qnil;
+}
+
 DEFUN ("funcall", Ffuncall, Sfuncall, 1, MANY, 0,
        doc: /* Call first argument as a function, passing remaining arguments to it.
 Return the value that function returns.
@@ -3115,8 +3255,9 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
           abort ();
         }
     }
-  if (COMPILEDP (fun))
-    val = funcall_lambda (fun, numargs, args + 1);
+
+  if (FUNVECP (fun))
+    val = funcall_lambda (fun, numargs, args + 1, Qnil);
   else
     {
       if (EQ (fun, Qunbound))
@@ -3127,7 +3268,13 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
       if (!SYMBOLP (funcar))
         xsignal1 (Qinvalid_function, original_fun);
       if (EQ (funcar, Qlambda))
-        val = funcall_lambda (fun, numargs, args + 1);
+        val = funcall_lambda (fun, numargs, args + 1, Qnil);
+      else if (EQ (funcar, Qclosure)
+               && CONSP (XCDR (fun))
+               && CONSP (XCDR (XCDR (fun)))
+               && EQ (XCAR (XCDR (XCDR (fun))), Qlambda))
+        val = funcall_lambda (XCDR (XCDR (fun)), numargs, args + 1,
+                              XCAR (XCDR (fun)));
       else if (EQ (funcar, Qautoload))
         {
           do_autoload (fun, original_fun);
@@ -3147,9 +3294,10 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
 }
 
 Lisp_Object
-apply_lambda (fun, args, eval_flag)
+apply_lambda (fun, args, eval_flag, lexenv)
      Lisp_Object fun, args;
      int eval_flag;
+     Lisp_Object lexenv;
 {
   Lisp_Object args_left;
   Lisp_Object numargs;
@@ -3181,7 +3329,7 @@ apply_lambda (fun, args, eval_flag)
       backtrace_list->nargs = i;
     }
   backtrace_list->evalargs = 0;
-  tem = funcall_lambda (fun, XINT (numargs), arg_vector);
+  tem = funcall_lambda (fun, XINT (numargs), arg_vector, lexenv);
 
   /* Do the debug-on-exit now, while arg_vector still exists.  */
   if (backtrace_list->debug_on_exit)
@@ -3191,20 +3339,100 @@ apply_lambda (fun, args, eval_flag)
   return tem;
 }
 
+
+/* Call a non-bytecode funvec object FUN, on the argments in ARGS (of
+   length NARGS).  */
+
+static Lisp_Object
+funcall_funvec (fun, nargs, args)
+     Lisp_Object fun;
+     int nargs;
+     Lisp_Object *args;
+{
+  int size = FUNVEC_SIZE (fun);
+  Lisp_Object tag = (size > 0 ? AREF (fun, 0) : Qnil);
+
+  if (EQ (tag, Qcurry))
+    {
+      /* A curried function is a way to attach arguments to a another
+         function. The first element of the vector is the identifier
+         `curry', the second is the wrapped function, and remaining
+         elements are the attached arguments.  */
+      int num_curried_args = size - 2;
+      /* Offset of the curried and user args in the final arglist.  Curried
+         args are first in the new arg vector, after the function.  User
+         args follow.  */
+      int curried_args_offs = 1;
+      int user_args_offs = curried_args_offs + num_curried_args;
+      /* The curried function and arguments.  */
+      Lisp_Object *curry_params = XVECTOR (fun)->contents + 1;
+      /* The arguments in the curry vector.  */
+      Lisp_Object *curried_args = curry_params + 1;
+      /* The number of arguments with which we'll call funcall, and the
+         arguments themselves.  */
+      int num_funcall_args = 1 + num_curried_args + nargs;
+      Lisp_Object *funcall_args
+        = (Lisp_Object *) alloca (num_funcall_args * sizeof (Lisp_Object));
+
+      /* First comes the real function.  */
+      funcall_args[0] = curry_params[0];
+
+      /* Then the arguments in the appropriate order.  */
+      bcopy (curried_args, funcall_args + curried_args_offs,
+             num_curried_args * sizeof (Lisp_Object));
+      bcopy (args, funcall_args + user_args_offs,
+             nargs * sizeof (Lisp_Object));
+
+      return Ffuncall (num_funcall_args, funcall_args);
+    }
+  else
+    xsignal1 (Qinvalid_function, fun);
+}
+
+
 /* Apply a Lisp function FUN to the NARGS evaluated arguments in ARG_VECTOR
    and return the result of evaluation.
    FUN must be either a lambda-expression or a compiled-code object.  */
 
 static Lisp_Object
-funcall_lambda (fun, nargs, arg_vector)
+funcall_lambda (fun, nargs, arg_vector, lexenv)
      Lisp_Object fun;
      int nargs;
      register Lisp_Object *arg_vector;
+     Lisp_Object lexenv;
 {
   Lisp_Object val, syms_left, next;
   int count = SPECPDL_INDEX ();
   int i, optional, rest;
 
+  if (COMPILEDP (fun)
+      && FUNVEC_SIZE (fun) > COMPILED_PUSH_ARGS
+      && ! NILP (XVECTOR (fun)->contents[COMPILED_PUSH_ARGS]))
+    /* A byte-code object with a non-nil `push args' slot means we
+       shouldn't bind any arguments, instead just call the byte-code
+       interpreter directly; it will push arguments as necessary.
+
+       Byte-code objects with either a non-existant, or a nil value for
+       the `push args' slot (the default), have dynamically-bound
+       arguments, and use the argument-binding code below instead (as do
+       all interpreted functions, even lexically bound ones).  */
+    {
+      /* If we have not actually read the bytecode string
+         and constants vector yet, fetch them from the file.  */
+      if (CONSP (AREF (fun, COMPILED_BYTECODE)))
+        Ffetch_bytecode (fun);
+      return exec_byte_code (AREF (fun, COMPILED_BYTECODE),
+                             AREF (fun, COMPILED_CONSTANTS),
+                             AREF (fun, COMPILED_STACK_DEPTH),
+                             AREF (fun, COMPILED_ARGLIST),
+                             nargs, arg_vector);
+    }
+
+  if (FUNVECP (fun) && !FUNVEC_COMPILED_P (fun))
+    /* Byte-compiled functions are handled directly below, but we
+       call other funvec types via funcall_funvec.  */
+    return funcall_funvec (fun, nargs, arg_vector);
+
   if (CONSP (fun))
     {
       syms_left = XCDR (fun);
@@ -3236,12 +3464,27 @@ funcall_lambda (fun, nargs, arg_vector)
           specbind (next, Flist (nargs - i, &arg_vector[i]));
           i = nargs;
         }
-      else if (i < nargs)
-        specbind (next, arg_vector[i++]);
-      else if (!optional)
-        xsignal2 (Qwrong_number_of_arguments, fun, make_number (nargs));
       else
-        specbind (next, Qnil);
+        {
+          Lisp_Object val;
+
+          /* Get the argument's actual value.  */
+          if (i < nargs)
+            val = arg_vector[i++];
+          else if (!optional)
+            xsignal2 (Qwrong_number_of_arguments, fun, make_number (nargs));
+          else
+            val = Qnil;
+
+          /* Bind the argument.  */
+          if (!NILP (lexenv)
+              && SYMBOLP (next) && !XSYMBOL (next)->declared_special)
+            /* Lexically bind NEXT by adding it to the lexenv alist.  */
+            lexenv = Fcons (Fcons (next, val), lexenv);
+          else
+            /* Dynamically bind NEXT.  */
+            specbind (next, val);
+        }
     }
 
   if (!NILP (syms_left))
@@ -3249,6 +3492,10 @@ funcall_lambda (fun, nargs, arg_vector)
   else if (i < nargs)
     xsignal2 (Qwrong_number_of_arguments, fun, make_number (nargs));
 
+  if (!EQ (lexenv, Vinternal_interpreter_environment))
+    /* Instantiate a new lexical environment.  */
+    specbind (Qinternal_interpreter_environment, lexenv);
+
   if (CONSP (fun))
     val = Fprogn (XCDR (XCDR (fun)));
   else
@@ -3257,9 +3504,10 @@ funcall_lambda (fun, nargs, arg_vector)
          and constants vector yet, fetch them from the file.  */
       if (CONSP (AREF (fun, COMPILED_BYTECODE)))
         Ffetch_bytecode (fun);
-      val = Fbyte_code (AREF (fun, COMPILED_BYTECODE),
-                        AREF (fun, COMPILED_CONSTANTS),
-                        AREF (fun, COMPILED_STACK_DEPTH));
+      val = exec_byte_code (AREF (fun, COMPILED_BYTECODE),
+                            AREF (fun, COMPILED_CONSTANTS),
+                            AREF (fun, COMPILED_STACK_DEPTH),
+                            Qnil, 0, 0);
     }
 
   return unbind_to (count, val);
@@ -3502,7 +3750,42 @@ unbind_to (count, value)
   UNGCPRO;
   return value;
 }
+
 
+
+DEFUN ("specialp", Fspecialp, Sspecialp, 1, 1, 0,
+       doc: /* Return non-nil if SYMBOL's global binding has been declared special.
+A special variable is one that will be bound dynamically, even in a
+context where binding is lexical by default.  */)
+  (symbol)
+     Lisp_Object symbol;
+{
+   CHECK_SYMBOL (symbol);
+   return XSYMBOL (symbol)->declared_special ? Qt : Qnil;
+}
+
+
+
+DEFUN ("curry", Fcurry, Scurry, 1, MANY, 0,
+       doc: /* Return FUN curried with ARGS.
+The result is a function-like object that will append any arguments it
+is called with to ARGS, and call FUN with the resulting list of arguments.
+
+For instance:
+  (funcall (curry '+ 3 4 5) 2) is the same as (funcall '+ 3 4 5 2)
+and:
+  (mapcar (curry 'concat "The ") '("a" "b" "c"))
+  => ("The a" "The b" "The c")
+
+usage: (curry FUN &rest ARGS)  */)
+     (nargs, args)
+     register int nargs;
+     Lisp_Object *args;
+{
+  return make_funvec (Qcurry, 0, nargs, args);
+}
+
+
 DEFUN ("backtrace-debug", Fbacktrace_debug, Sbacktrace_debug, 2, 2, 0,
        doc: /* Set the debug-on-exit flag of eval frame LEVEL levels down to FLAG.
 The debugger is entered when that frame exits, if the flag is non-nil.  */)
@@ -3713,6 +3996,15 @@ before making `inhibit-quit' nil.  */);
   Qand_optional = intern_c_string ("&optional");
   staticpro (&Qand_optional);
 
+  Qclosure = intern_c_string ("closure");
+  staticpro (&Qclosure);
+
+  Qcurry = intern_c_string ("curry");
+  staticpro (&Qcurry);
+
+  Qunevalled = intern_c_string ("unevalled");
+  staticpro (&Qunevalled);
+
   Qdebug = intern_c_string ("debug");
   staticpro (&Qdebug);
 
@@ -3788,6 +4080,17 @@ DECL is a list `(declare ...)' containing the declarations.
 The value the function returns is not used.  */);
   Vmacro_declaration_function = Qnil;
 
+  Qinternal_interpreter_environment
+    = intern_c_string ("internal-interpreter-environment");
+  staticpro (&Qinternal_interpreter_environment);
+  DEFVAR_LISP ("internal-interpreter-environment",
+               &Vinternal_interpreter_environment,
+               doc: /* If non-nil, the current lexical environment of the lisp interpreter.
+When lexical binding is not being used, this variable is nil.
+A value of `(t)' indicates an empty environment, otherwise it is an
+alist of active lexical bindings.  */);
+  Vinternal_interpreter_environment = Qnil;
+
   Vrun_hooks = intern_c_string ("run-hooks");
   staticpro (&Vrun_hooks);
 
@@ -3833,9 +4136,13 @@ The value the function returns is not used.  */);
   defsubr (&Srun_hook_with_args_until_success);
   defsubr (&Srun_hook_with_args_until_failure);
   defsubr (&Sfetch_bytecode);
+  defsubr (&Scurry);
   defsubr (&Sbacktrace_debug);
   defsubr (&Sbacktrace);
   defsubr (&Sbacktrace_frame);
+  defsubr (&Scurry);
+  defsubr (&Sspecialp);
+  defsubr (&Sfunctionp);
 }
 
 /* arch-tag: 014a07aa-33ab-4a8f-a3d2-ee8a4a9ff7fb
diff --git a/src/fns.c b/src/fns.c
index 3f984905d1e..9569c214268 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -149,8 +149,8 @@ To get the number of bytes, use `string-bytes'.  */)
     XSETFASTINT (val, MAX_CHAR);
   else if (BOOL_VECTOR_P (sequence))
     XSETFASTINT (val, XBOOL_VECTOR (sequence)->size);
-  else if (COMPILEDP (sequence))
-    XSETFASTINT (val, ASIZE (sequence) & PSEUDOVECTOR_SIZE_MASK);
+  else if (FUNVECP (sequence))
+    XSETFASTINT (val, FUNVEC_SIZE (sequence));
   else if (CONSP (sequence))
     {
       i = 0;
@@ -535,7 +535,7 @@ concat (nargs, args, target_type, last_special)
     {
       this = args[argnum];
       if (!(CONSP (this) || NILP (this) || VECTORP (this) || STRINGP (this)
-            || COMPILEDP (this) || BOOL_VECTOR_P (this)))
+            || FUNVECP (this) || BOOL_VECTOR_P (this)))
         wrong_type_argument (Qsequencep, this);
     }
 
@@ -559,7 +559,7 @@ concat (nargs, args, target_type, last_special)
           Lisp_Object ch;
           int this_len_byte;
 
-          if (VECTORP (this))
+          if (VECTORP (this) || FUNVECP (this))
             for (i = 0; i < len; i++)
               {
                 ch = AREF (this, i);
@@ -1383,7 +1383,9 @@ DEFUN ("elt", Felt, Selt, 2, 2, 0,
     return Fcar (Fnthcdr (n, sequence));
 
   /* Faref signals a "not array" error, so check here.  */
-  CHECK_ARRAY (sequence, Qsequencep);
+  if (! FUNVECP (sequence))
+    CHECK_ARRAY (sequence, Qsequencep);
+
   return Faref (sequence, n);
 }
 
@@ -2199,13 +2201,14 @@ internal_equal (o1, o2, depth, props)
         if (WINDOW_CONFIGURATIONP (o1))
           return compare_window_configurations (o1, o2, 0);
 
-        /* Aside from them, only true vectors, char-tables, compiled
-           functions, and fonts (font-spec, font-entity, font-ojbect)
-           are sensible to compare, so eliminate the others now.  */
+        /* Aside from them, only true vectors, char-tables, function vectors,
+           and fonts (font-spec, font-entity, font-ojbect) are sensible to
+           compare, so eliminate the others now.  */
         if (size & PSEUDOVECTOR_FLAG)
           {
-            if (!(size & (PVEC_COMPILED
-                          | PVEC_CHAR_TABLE | PVEC_SUB_CHAR_TABLE | PVEC_FONT)))
+            if (!(size & (PVEC_FUNVEC
+                          | PVEC_CHAR_TABLE | PVEC_SUB_CHAR_TABLE
+                          | PVEC_FONT)))
               return 0;
             size &= PSEUDOVECTOR_SIZE_MASK;
           }
@@ -2416,7 +2419,7 @@ mapcar1 (leni, vals, fn, seq)
     1) lists are not relocated and 2) the list is marked via `seq' so will not
     be freed */
 
-  if (VECTORP (seq))
+  if (VECTORP (seq) || FUNVECP (seq))
     {
       for (i = 0; i < leni; i++)
         {
diff --git a/src/image.c b/src/image.c
index b9620e10948..67c228cbc7f 100644
--- a/src/image.c
+++ b/src/image.c
@@ -885,7 +885,7 @@ parse_image_spec (spec, keywords, nkeywords, type)
         case IMAGE_FUNCTION_VALUE:
           value = indirect_function (value);
           if (SUBRP (value)
-              || COMPILEDP (value)
+              || FUNVECP (value)
               || (CONSP (value) && EQ (XCAR (value), Qlambda)))
             break;
           return 0;
diff --git a/src/keyboard.c b/src/keyboard.c
index 63372d600e3..18d75f9b01c 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -10390,7 +10390,7 @@ a special event, so ignore the prefix argument and don't clear it.  */)
       return Fexecute_kbd_macro (final, prefixarg, Qnil);
     }
 
-  if (CONSP (final) || SUBRP (final) || COMPILEDP (final))
+  if (CONSP (final) || SUBRP (final) || FUNVECP (final))
     /* Don't call Fcall_interactively directly because we want to make
        sure the backtrace has an entry for `call-interactively'.
        For the same reason, pass `cmd' rather than `final'.  */
diff --git a/src/lisp.h b/src/lisp.h
index 1941a2471a4..c7e8ea0fb8b 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -344,7 +344,7 @@ enum pvec_type
   PVEC_NORMAL_VECTOR = 0,
   PVEC_PROCESS = 0x200,
   PVEC_FRAME = 0x400,
-  PVEC_COMPILED = 0x800,
+  PVEC_FUNVEC = 0x800,
   PVEC_WINDOW = 0x1000,
   PVEC_WINDOW_CONFIGURATION = 0x2000,
   PVEC_SUBR = 0x4000,
@@ -623,7 +623,7 @@ extern size_t pure_size;
 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
 #define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
-#define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
+#define XSETFUNVEC(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FUNVEC))
 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
 #define XSETBOOL_VECTOR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BOOL_VECTOR))
@@ -639,6 +639,9 @@ extern size_t pure_size;
    eassert ((IDX) >= 0 && (IDX) < ASIZE (ARRAY)),       \
    AREF ((ARRAY), (IDX)) = (VAL))
 
+/* Return the size of the psuedo-vector object FUNVEC.  */
+#define FUNVEC_SIZE(funvec)     (ASIZE (funvec) & PSEUDOVECTOR_SIZE_MASK)
+
 /* Convenience macros for dealing with Lisp strings.  */
 
 #define SDATA(string)           (XSTRING (string)->data + 0)
@@ -1020,6 +1023,10 @@ struct Lisp_Symbol
   /* Interned state of the symbol.  This is an enumerator from
      enum symbol_interned.  */
   unsigned interned : 2;
+  
+  /* Non-zero means that this variable has been explicitly declared
+     special (with `defvar' etc), and shouldn't be lexically bound.  */
+  unsigned declared_special : 1;
 
   /* The symbol's name, as a Lisp string.
 
@@ -1475,7 +1482,7 @@ struct Lisp_Float
 typedef unsigned char UCHAR;
 #endif
 
-/* Meanings of slots in a Lisp_Compiled:  */
+/* Meanings of slots in a byte-compiled function vector:  */
 
 #define COMPILED_ARGLIST 0
 #define COMPILED_BYTECODE 1
@@ -1483,6 +1490,25 @@ typedef unsigned char UCHAR;
 #define COMPILED_STACK_DEPTH 3
 #define COMPILED_DOC_STRING 4
 #define COMPILED_INTERACTIVE 5
+#define COMPILED_PUSH_ARGS 6
+
+/* Return non-zero if TAG, the first element from a funvec object, refers
+   to a byte-code object.  Byte-code objects are distinguished from other
+   `funvec' objects by having a (possibly empty) list as their first
+   element -- other funvec types use a non-nil symbol there.  */
+#define FUNVEC_COMPILED_TAG_P(tag)                                            \
+  (NILP (tag) || CONSP (tag))
+
+/* Return non-zero if FUNVEC, which should be a `funvec' object, is a
+   byte-compiled function. Byte-compiled function are funvecs with the
+   arglist as the first element (other funvec types will have a symbol
+   identifying the type as the first object).  */
+#define FUNVEC_COMPILED_P(funvec)                                             \
+  (FUNVEC_SIZE (funvec) > 0 && FUNVEC_COMPILED_TAG_P (AREF (funvec, 0)))
+
+/* Return non-zero if OBJ is byte-compile function.  */
+#define COMPILEDP(obj)                                                        \
+  (FUNVECP (obj) && FUNVEC_COMPILED_P (obj))
 
 /* Flag bits in a character.  These also get used in termhooks.h.
    Richard Stallman <rms@gnu.ai.mit.edu> thinks that MULE
@@ -1604,7 +1630,7 @@ typedef struct {
 #define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
 #define TERMINALP(x) PSEUDOVECTORP (x, PVEC_TERMINAL)
 #define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
-#define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
+#define FUNVECP(x) PSEUDOVECTORP (x, PVEC_FUNVEC)
 #define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
 #define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
 #define SUB_CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_SUB_CHAR_TABLE)
@@ -1797,7 +1823,7 @@ typedef struct {
 #define FUNCTIONP(OBJ)                                  \
      ((CONSP (OBJ) && EQ (XCAR (OBJ), Qlambda))         \
       || (SYMBOLP (OBJ) && !NILP (Ffboundp (OBJ)))      \
-      || COMPILEDP (OBJ)                                \
+      || FUNVECP (OBJ)                                  \
       || SUBRP (OBJ))
 
 /* defsubr (Sname);
@@ -2697,6 +2723,7 @@ EXFUN (Fmake_list, 2);
 extern Lisp_Object allocate_misc P_ ((void));
 EXFUN (Fmake_vector, 2);
 EXFUN (Fvector, MANY);
+EXFUN (Ffunvec, MANY);
 EXFUN (Fmake_symbol, 1);
 EXFUN (Fmake_marker, 0);
 EXFUN (Fmake_string, 2);
@@ -2715,6 +2742,7 @@ extern Lisp_Object make_pure_c_string (const char *data);
 extern Lisp_Object pure_cons P_ ((Lisp_Object, Lisp_Object));
 extern Lisp_Object make_pure_vector P_ ((EMACS_INT));
 EXFUN (Fgarbage_collect, 0);
+extern Lisp_Object make_funvec P_ ((Lisp_Object, int, int, Lisp_Object *));
 EXFUN (Fmake_byte_code, MANY);
 EXFUN (Fmake_bool_vector, 2);
 extern Lisp_Object Qchar_table_extra_slots;
@@ -2894,7 +2922,7 @@ extern Lisp_Object call5 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object
 extern Lisp_Object call6 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
 extern Lisp_Object call7 P_ ((Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object, Lisp_Object));
 EXFUN (Fdo_auto_save, 2);
-extern Lisp_Object apply_lambda P_ ((Lisp_Object, Lisp_Object, int));
+extern Lisp_Object apply_lambda P_ ((Lisp_Object, Lisp_Object, int, Lisp_Object));
 extern Lisp_Object internal_catch P_ ((Lisp_Object, Lisp_Object (*) (Lisp_Object), Lisp_Object));
 extern Lisp_Object internal_lisp_condition_case P_ ((Lisp_Object, Lisp_Object, Lisp_Object));
 extern Lisp_Object internal_condition_case P_ ((Lisp_Object (*) (void), Lisp_Object, Lisp_Object (*) (Lisp_Object)));
@@ -3312,11 +3340,13 @@ extern int read_bytecode_char P_ ((int));
 
 /* Defined in bytecode.c */
 extern Lisp_Object Qbytecode;
-EXFUN (Fbyte_code, 3);
+EXFUN (Fbyte_code, MANY);
 extern void syms_of_bytecode P_ ((void));
 extern struct byte_stack *byte_stack_list;
 extern void mark_byte_stack P_ ((void));
 extern void unmark_byte_stack P_ ((void));
+extern Lisp_Object exec_byte_code P_ ((Lisp_Object, Lisp_Object, Lisp_Object,
+                                       Lisp_Object, int, Lisp_Object *));
 
 /* Defined in macros.c */
 extern Lisp_Object Qexecute_kbd_macro;
diff --git a/src/lread.c b/src/lread.c
index 3a77a62b27f..53f26faea36 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -83,6 +83,7 @@ Lisp_Object Qascii_character, Qload, Qload_file_name;
 Lisp_Object Qbackquote, Qcomma, Qcomma_at, Qcomma_dot, Qfunction;
 Lisp_Object Qinhibit_file_name_operation;
 Lisp_Object Qeval_buffer_list, Veval_buffer_list;
+Lisp_Object Qlexical_binding;
 Lisp_Object Qfile_truename, Qdo_after_load_evaluation; /* ACM 2006/5/16 */
 
 /* Used instead of Qget_file_char while loading *.elc files compiled
@@ -93,6 +94,7 @@ static Lisp_Object Qload_force_doc_strings;
 
 extern Lisp_Object Qevent_symbol_element_mask;
 extern Lisp_Object Qfile_exists_p;
+extern Lisp_Object Qinternal_interpreter_environment;
 
 /* non-zero if inside `load' */
 int load_in_progress;
@@ -157,6 +159,9 @@ Lisp_Object Vread_with_symbol_positions;
 /* List of (SYMBOL . POSITION) accumulated so far. */
 Lisp_Object Vread_symbol_positions_list;
 
+/* If non-nil `readevalloop' evaluates code in a lexical environment.  */
+Lisp_Object Vlexical_binding;
+
 /* List of descriptors now open for Fload.  */
 static Lisp_Object load_descriptor_list;
 
@@ -864,6 +869,118 @@ DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
 
 
 
+
+/* Return true if the lisp code read using READCHARFUN defines a non-nil
+   `lexical-binding' file variable.  After returning, the stream is
+   positioned following the first line, if it is a comment, otherwise
+   nothing is read.  */
+
+static int
+lisp_file_lexically_bound_p (readcharfun)
+     Lisp_Object readcharfun;
+{
+  int ch = READCHAR;
+  if (ch != ';')
+    /* The first line isn't a comment, just give up.  */
+    {
+      UNREAD (ch);
+      return 0;
+    }
+  else
+    /* Look for an appropriate file-variable in the first line.  */
+    {
+      int rv = 0;
+      enum {
+        NOMINAL, AFTER_FIRST_DASH, AFTER_ASTERIX,
+      } beg_end_state = NOMINAL;
+      int in_file_vars = 0;
+
+#define UPDATE_BEG_END_STATE(ch)                                              \
+  if (beg_end_state == NOMINAL)                                               \
+    beg_end_state = (ch == '-' ? AFTER_FIRST_DASH : NOMINAL);                 \
+  else if (beg_end_state == AFTER_FIRST_DASH)                                 \
+    beg_end_state = (ch == '*' ? AFTER_ASTERIX : NOMINAL);                    \
+  else if (beg_end_state == AFTER_ASTERIX)                                    \
+    {                                                                         \
+      if (ch == '-')                                                          \
+        in_file_vars = !in_file_vars;                                         \
+      beg_end_state = NOMINAL;                                                \
+    }
+
+      /* Skip until we get to the file vars, if any.  */
+      do
+        {
+          ch = READCHAR;
+          UPDATE_BEG_END_STATE (ch);
+        }
+      while (!in_file_vars && ch != '\n' && ch != EOF);
+
+      while (in_file_vars)
+        {
+          char var[100], *var_end, val[100], *val_end;
+
+          ch = READCHAR;
+
+          /* Read a variable name.  */
+          while (ch == ' ' || ch == '\t')
+            ch = READCHAR;
+
+          var_end = var;
+          while (ch != ':' && ch != '\n' && ch != EOF)
+            {
+              if (var_end < var + sizeof var - 1)
+                *var_end++ = ch;
+              UPDATE_BEG_END_STATE (ch);
+              ch = READCHAR;
+            }
+          
+          while (var_end > var
+                 && (var_end[-1] == ' ' || var_end[-1] == '\t'))
+            var_end--;
+          *var_end = '\0';
+
+          if (ch == ':')
+            {
+              /* Read a variable value.  */
+              ch = READCHAR;
+
+              while (ch == ' ' || ch == '\t')
+                ch = READCHAR;
+
+              val_end = val;
+              while (ch != ';' && ch != '\n' && ch != EOF && in_file_vars)
+                {
+                  if (val_end < val + sizeof val - 1)
+                    *val_end++ = ch;
+                  UPDATE_BEG_END_STATE (ch);
+                  ch = READCHAR;
+                }
+              if (! in_file_vars)
+                /* The value was terminated by an end-marker, which
+                   remove.  */
+                val_end -= 3;
+              while (val_end > val
+                     && (val_end[-1] == ' ' || val_end[-1] == '\t'))
+                val_end--;
+              *val_end = '\0';
+
+              if (strcmp (var, "lexical-binding") == 0)
+                /* This is it...  */
+                {
+                  rv = (strcmp (val, "nil") != 0);
+                  break;
+                }
+            }
+        }
+
+      while (ch != '\n' && ch != EOF)
+        ch = READCHAR;
+
+      return rv;
+    }
+}
+
+
 /* Value is a version number of byte compiled code if the file
    associated with file descriptor FD is a compiled Lisp file that's
    safe to load.  Only files compiled with Emacs are safe to load.
@@ -1129,6 +1246,12 @@ Return t if the file exists and loads successfully.  */)
     Vloads_in_progress = Fcons (found, Vloads_in_progress);
   }
 
+  /* All loads are by default dynamic, unless the file itself specifies
+     otherwise using a file-variable in the first line.  This is bound here
+     so that it takes effect whether or not we use
+     Vload_source_file_function.  */
+  specbind (Qlexical_binding, Qnil);
+
   /* Get the name for load-history. */
   hist_file_name = (! NILP (Vpurify_flag)
                     ? Fconcat (2, (tmp[0] = Ffile_name_directory (file),
@@ -1253,7 +1376,13 @@ Return t if the file exists and loads successfully.  */)
   specbind (Qinhibit_file_name_operation, Qnil);
   load_descriptor_list
     = Fcons (make_number (fileno (stream)), load_descriptor_list);
+
   specbind (Qload_in_progress, Qt);
+
+  instream = stream;
+  if (lisp_file_lexically_bound_p (Qget_file_char))
+    Fset (Qlexical_binding, Qt);
+
   if (! version || version >= 22)
     readevalloop (Qget_file_char, stream, hist_file_name,
                   Feval, 0, Qnil, Qnil, Qnil, Qnil);
@@ -1652,6 +1781,7 @@ readevalloop (readcharfun, stream, sourcename, evalfun,
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
   struct buffer *b = 0;
   int continue_reading_p;
+  Lisp_Object lex_bound;
   /* Nonzero if reading an entire buffer.  */
   int whole_buffer = 0;
   /* 1 on the first time around.  */
@@ -1677,6 +1807,15 @@ readevalloop (readcharfun, stream, sourcename, evalfun,
   record_unwind_protect (readevalloop_1, load_convert_to_unibyte ? Qt : Qnil);
   load_convert_to_unibyte = !NILP (unibyte);
 
+  /* If lexical binding is active (either because it was specified in
+     the file's header, or via a buffer-local variable), create an empty
+     lexical environment, otherwise, turn off lexical binding.  */
+  lex_bound = find_symbol_value (Qlexical_binding);
+  if (NILP (lex_bound) || EQ (lex_bound, Qunbound))
+    specbind (Qinternal_interpreter_environment, Qnil);
+  else
+    specbind (Qinternal_interpreter_environment, Fcons (Qt, Qnil));
+
   GCPRO4 (sourcename, readfun, start, end);
 
   /* Try to ensure sourcename is a truename, except whilst preloading. */
@@ -1837,8 +1976,11 @@ This function preserves the position of point.  */)
 
   specbind (Qeval_buffer_list, Fcons (buf, Veval_buffer_list));
   specbind (Qstandard_output, tem);
+  specbind (Qlexical_binding, Qnil);
   record_unwind_protect (save_excursion_restore, save_excursion_save ());
   BUF_TEMP_SET_PT (XBUFFER (buf), BUF_BEGV (XBUFFER (buf)));
+  if (lisp_file_lexically_bound_p (buf))
+    Fset (Qlexical_binding, Qt);
   readevalloop (buf, 0, filename, Feval,
                 !NILP (printflag), unibyte, Qnil, Qnil, Qnil);
   unbind_to (count, Qnil);
@@ -2481,14 +2623,8 @@ read1 (readcharfun, pch, first_in_list)
           invalid_syntax ("#&...", 5);
         }
       if (c == '[')
-        {
-          /* Accept compiled functions at read-time so that we don't have to
-             build them using function calls.  */
-          Lisp_Object tmp;
-          tmp = read_vector (readcharfun, 1);
-          return Fmake_byte_code (XVECTOR (tmp)->size,
-                                  XVECTOR (tmp)->contents);
-        }
+        /* `function vector' objects, including byte-compiled functions.  */
+        return read_vector (readcharfun, 1);
       if (c == '(')
         {
           Lisp_Object tmp;
@@ -3300,9 +3436,9 @@ isfloat_string (cp, ignore_trailing)
 
 
 static Lisp_Object
-read_vector (readcharfun, bytecodeflag)
+read_vector (readcharfun, read_funvec)
      Lisp_Object readcharfun;
-     int bytecodeflag;
+     int read_funvec;
 {
   register int i;
   register int size;
@@ -3310,6 +3446,11 @@ read_vector (readcharfun, bytecodeflag)
   register Lisp_Object tem, item, vector;
   register struct Lisp_Cons *otem;
   Lisp_Object len;
+  /* If we're reading a funvec object we start out assuming it's also a
+     byte-code object (a subset of funvecs), so we can do any special
+     processing needed.  If it's just an ordinary funvec object, we'll
+     realize that as soon as we've read the first element.  */
+  int read_bytecode = read_funvec;
 
   tem = read_list (1, readcharfun);
   len = Flength (tem);
@@ -3320,11 +3461,19 @@ read_vector (readcharfun, bytecodeflag)
   for (i = 0; i < size; i++)
     {
       item = Fcar (tem);
+
+      /* If READ_BYTECODE is set, check whether this is really a byte-code
+         object, or just an ordinary `funvec' object -- non-byte-code
+         funvec objects use the same reader syntax.  We can tell from the
+         first element which one it is.  */
+      if (read_bytecode && i == 0 && ! FUNVEC_COMPILED_TAG_P (item))
+        read_bytecode = 0;      /* Nope. */
+
       /* If `load-force-doc-strings' is t when reading a lazily-loaded
          bytecode object, the docstring containing the bytecode and
          constants values must be treated as unibyte and passed to
          Fread, to get the actual bytecode string and constants vector.  */
-      if (bytecodeflag && load_force_doc_strings)
+      if (read_bytecode && load_force_doc_strings)
         {
           if (i == COMPILED_BYTECODE)
             {
@@ -3377,6 +3526,14 @@ read_vector (readcharfun, bytecodeflag)
       tem = Fcdr (tem);
       free_cons (otem);
     }
+
+  if (read_bytecode && size >= 4)
+    /* Convert this vector to a bytecode object.  */
+    vector = Fmake_byte_code (size, XVECTOR (vector)->contents);
+  else if (read_funvec && size >= 1)
+    /* Convert this vector to an ordinary funvec object.  */
+    XSETFUNVEC (vector, XVECTOR (vector));
+
   return vector;
 }
 
@@ -3979,6 +4136,7 @@ defvar_int (struct Lisp_Intfwd *i_fwd,
   sym = intern_c_string (namestring);
   i_fwd->type = Lisp_Fwd_Int;
   i_fwd->intvar = address;
+  XSYMBOL (sym)->declared_special = 1;
   XSYMBOL (sym)->redirect = SYMBOL_FORWARDED;
   SET_SYMBOL_FWD (XSYMBOL (sym), (union Lisp_Fwd *)i_fwd);
 }
@@ -3993,6 +4151,7 @@ defvar_bool (struct Lisp_Boolfwd *b_fwd,
   sym = intern_c_string (namestring);
   b_fwd->type = Lisp_Fwd_Bool;
   b_fwd->boolvar = address;
+  XSYMBOL (sym)->declared_special = 1;
   XSYMBOL (sym)->redirect = SYMBOL_FORWARDED;
   SET_SYMBOL_FWD (XSYMBOL (sym), (union Lisp_Fwd *)b_fwd);
   Vbyte_boolean_vars = Fcons (sym, Vbyte_boolean_vars);
@@ -4011,6 +4170,7 @@ defvar_lisp_nopro (struct Lisp_Objfwd *o_fwd,
   sym = intern_c_string (namestring);
   o_fwd->type = Lisp_Fwd_Obj;
   o_fwd->objvar = address;
+  XSYMBOL (sym)->declared_special = 1;
   XSYMBOL (sym)->redirect = SYMBOL_FORWARDED;
   SET_SYMBOL_FWD (XSYMBOL (sym), (union Lisp_Fwd *)o_fwd);
 }
@@ -4023,6 +4183,7 @@ defvar_lisp (struct Lisp_Objfwd *o_fwd,
   staticpro (address);
 }
 
+
 /* Similar but define a variable whose value is the Lisp Object stored
    at a particular offset in the current kboard object.  */
 
@@ -4034,6 +4195,7 @@ defvar_kboard (struct Lisp_Kboard_Objfwd *ko_fwd,
   sym = intern_c_string (namestring);
   ko_fwd->type = Lisp_Fwd_Kboard_Obj;
   ko_fwd->offset = offset;
+  XSYMBOL (sym)->declared_special = 1;
   XSYMBOL (sym)->redirect = SYMBOL_FORWARDED;
   SET_SYMBOL_FWD (XSYMBOL (sym), (union Lisp_Fwd *)ko_fwd);
 }
@@ -4463,6 +4625,16 @@ to load.  See also `load-dangerous-libraries'.  */);
   Vbytecomp_version_regexp
     = make_pure_c_string ("^;;;.\\(in Emacs version\\|bytecomp version FSF\\)");
 
+  Qlexical_binding = intern ("lexical-binding");
+  staticpro (&Qlexical_binding);
+  DEFVAR_LISP ("lexical-binding", &Vlexical_binding,
+               doc: /* If non-nil, use lexical binding when evaluating code.
+This only applies to code evaluated by `eval-buffer' and `eval-region'.
+This variable is automatically set from the file variables of an interpreted
+  lisp file read using `load'.
+This variable automatically becomes buffer-local when set.  */);
+  Fmake_variable_buffer_local (Qlexical_binding);
+
   DEFVAR_LISP ("eval-buffer-list", &Veval_buffer_list,
                doc: /* List of buffers being read from by calls to `eval-buffer' and `eval-region'.  */);
   Veval_buffer_list = Qnil;
diff --git a/src/print.c b/src/print.c
index 6d403e00fe0..fb298233666 100644
--- a/src/print.c
+++ b/src/print.c
@@ -1340,7 +1340,7 @@ print_preprocess (obj)
 
  loop:
   if (STRINGP (obj) || CONSP (obj) || VECTORP (obj)
-      || COMPILEDP (obj) || CHAR_TABLE_P (obj) || SUB_CHAR_TABLE_P (obj)
+      || FUNVECP (obj) || CHAR_TABLE_P (obj) || SUB_CHAR_TABLE_P (obj)
       || HASH_TABLE_P (obj)
       || (! NILP (Vprint_gensym)
           && SYMBOLP (obj)
@@ -1543,7 +1543,7 @@ print_object (obj, printcharfun, escapeflag)
 
   /* Detect circularities and truncate them.  */
   if (STRINGP (obj) || CONSP (obj) || VECTORP (obj)
-      || COMPILEDP (obj) || CHAR_TABLE_P (obj) || SUB_CHAR_TABLE_P (obj)
+      || FUNVECP (obj) || CHAR_TABLE_P (obj) || SUB_CHAR_TABLE_P (obj)
       || HASH_TABLE_P (obj)
       || (! NILP (Vprint_gensym)
           && SYMBOLP (obj)
@@ -2175,7 +2175,7 @@ print_object (obj, printcharfun, escapeflag)
       else
         {
           EMACS_INT size = XVECTOR (obj)->size;
-          if (COMPILEDP (obj))
+          if (FUNVECP (obj))
             {
               PRINTCHAR ('#');
               size &= PSEUDOVECTOR_SIZE_MASK;