From b9598260f96ddc652cd82ab64bbe922ccfc48a29 Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Sun, 13 Jun 2010 16:36:17 -0400
Subject: 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.

---
 src/bytecode.c | 128 ++++++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 122 insertions(+), 6 deletions(-)

(limited to 'src/bytecode.c')

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:
-- 
cgit v1.2.1


From 3c3ddb9833996729545bb4909bea359e5dbaa02e Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Mon, 14 Jun 2010 22:51:25 -0400
Subject: * lisp/emacs-lisp/bytecomp.el
 (byte-compile-initial-macro-environment): Don't macroexpand before evaluating
 in eval-and-compile, in case `body's macro expansion uses macros and
 functions defined in itself.

* src/bytecode.c (exec_byte_code):
* src/eval.c (Ffunctionp): Fix up int/Lisp_Object confusions.
---
 src/bytecode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index fec855c0b83..192d397c45f 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1742,7 +1742,7 @@ exec_byte_code (bytestr, vector, maxdepth, args_template, nargs, args)
 	    if (! VECTORP (vec))
 	      wrong_type_argument (Qvectorp, vec);
 	    else if (index < 0 || index >= XVECTOR (vec)->size)
-	      args_out_of_range (vec, index);
+	      args_out_of_range (vec, make_number (index));
 
 	    if (op == Bvec_ref)
 	      PUSH (XVECTOR (vec)->contents[index]);
-- 
cgit v1.2.1


From defb141157dfa37c33cdcbfa4b29c702a8fc9edf Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Mon, 13 Dec 2010 22:37:44 -0500
Subject: Try and be more careful about propagation of lexical environment. *
 src/eval.c (apply_lambda, funcall_lambda): Remove lexenv arg. (Feval): Always
 eval in the empty environment. (eval_sub): New function.  Use it for all
 calls to Feval that should evaluate in the lexical environment of the caller.
 Pass `closure's as is to apply_lambda. (Ffuncall): Pass `closure's as is to
 funcall_lambda. (funcall_lambda): Extract lexenv for `closure's, when
 applicable. Also use lexical scoping for the &rest argument, if applicable. *
 src/lisp.h (eval_sub): Declare. * src/lread.c (readevalloop): Remove
 `evalfun' argument. * src/print.c (Fwith_output_to_temp_buffer): * src/data.c
 (Fsetq_default): Use eval_sub. * lisp/emacs-lisp/bytecomp.el
 (byte-compile-condition-case): Use push.

---
 src/bytecode.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index d94b19b2d07..01fce0577b0 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -901,7 +901,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 
 	case Bsave_window_excursion:
 	  BEFORE_POTENTIAL_GC ();
-	  TOP = Fsave_window_excursion (TOP);
+	  TOP = Fsave_window_excursion (TOP); /* FIXME: lexbind */
 	  AFTER_POTENTIAL_GC ();
 	  break;
 
@@ -915,13 +915,13 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	    Lisp_Object v1;
 	    BEFORE_POTENTIAL_GC ();
 	    v1 = POP;
-	    TOP = internal_catch (TOP, Feval, v1);
+	    TOP = internal_catch (TOP, Feval, v1); /* FIXME: lexbind */
 	    AFTER_POTENTIAL_GC ();
 	    break;
 	  }
 
 	case Bunwind_protect:
-	  record_unwind_protect (Fprogn, POP);
+	  record_unwind_protect (Fprogn, POP); /* FIXME: lexbind */
 	  break;
 
 	case Bcondition_case:
@@ -930,7 +930,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	    handlers = POP;
 	    body = POP;
 	    BEFORE_POTENTIAL_GC ();
-	    TOP = internal_lisp_condition_case (TOP, body, handlers);
+	    TOP = internal_lisp_condition_case (TOP, body, handlers); /* FIXME: lexbind */
 	    AFTER_POTENTIAL_GC ();
 	    break;
 	  }
-- 
cgit v1.2.1


From a0ee6f2751acba71df443d4d795bb350eb6421dd Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Wed, 15 Dec 2010 12:46:59 -0500
Subject: Obey lexical-binding in interactive evaluation commands. *
 lisp/emacs-lisp/edebug.el (edebug-eval-defun, edebug-eval): *
 lisp/emacs-lisp/lisp-mode.el (eval-last-sexp-1, eval-defun-1): * lisp/ielm.el
 (ielm-eval-input): * lisp/simple.el (eval-expression): Use new eval arg to
 obey lexical-binding.

* src/eval.c (Feval): Add `lexical' argument.  Adjust callers.
(Ffuncall, eval_sub): Avoid goto.
---
 src/bytecode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 01fce0577b0..eb12b9c4963 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -915,7 +915,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	    Lisp_Object v1;
 	    BEFORE_POTENTIAL_GC ();
 	    v1 = POP;
-	    TOP = internal_catch (TOP, Feval, v1); /* FIXME: lexbind */
+	    TOP = internal_catch (TOP, eval_sub, v1); /* FIXME: lexbind */
 	    AFTER_POTENTIAL_GC ();
 	    break;
 	  }
-- 
cgit v1.2.1


From ce5b520a3758e22c6516e0d864d8c1a3512bf457 Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Sat, 12 Feb 2011 00:53:30 -0500
Subject: * lisp/emacs-lisp/byte-lexbind.el: Delete. *
 lisp/emacs-lisp/bytecomp.el (byte-compile-current-heap-environment)
 (byte-compile-current-num-closures): Remove vars. (byte-vec-ref,
 byte-vec-set): Remove byte codes. (byte-compile-arglist-vars,
 byte-compile-make-lambda-lexenv): Move from byte-lexbind.el.
 (byte-compile-lambda): Never build a closure. (byte-compile-closure-code-p,
 byte-compile-make-closure): Remove. (byte-compile-closure): Simplify.
 (byte-compile-top-level): Don't mess with heap environments.
 (byte-compile-dynamic-variable-bind): Always maintain
 byte-compile-bound-variables. (byte-compile-variable-ref,
 byte-compile-variable-set): Always just use the stack for lexical vars.
 (byte-compile-push-binding-init): Simplify. (byte-compile-not-lexical-var-p):
 New function, moved from cconv.el. (byte-compile-bind, byte-compile-unbind):
 New functions, moved and simplified from byte-lexbind.el. (byte-compile-let,
 byte-compile-let*): Simplify. (byte-compile-condition-case): Don't add
 :fun-body to the bound vars. (byte-compile-defmacro): Simplify. *
 lisp/emacs-lisp/byte-opt.el (byte-compile-side-effect-free-ops)
 (byte-optimize-lapcode): Remove byte-vec-ref and byte-vec-set. *
 lisp/emacs-lisp/cconv.el (cconv-not-lexical-var-p): Remove. (cconv-freevars,
 cconv-analyse-function, cconv-analyse-form): Use
 byte-compile-not-lexical-var-p instead. * src/bytecode.c (Bvec_ref,
 Bvec_set): Remove. (exec_byte_code): Don't handle them. * lisp/help-fns.el
 (describe-function-1): Fix paren typo.

---
 src/bytecode.c | 23 -----------------------
 1 file changed, 23 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 96d2aa273f2..9bf6ae45ce9 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -231,8 +231,6 @@ extern Lisp_Object Qand_optional, Qand_rest;
 /* 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
@@ -1722,27 +1720,6 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	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, make_number (index));
-
-	    if (op == Bvec_ref)
-	      PUSH (XVECTOR (vec)->contents[index]);
-	    else
-	      XVECTOR (vec)->contents[index] = POP;
-	  }
-	  break;
 	case BdiscardN:
 	  op = FETCH;
 	  if (op & 0x80)
-- 
cgit v1.2.1


From 5d8ea1203d1e659bc77d953784a85a6e7da0ce95 Mon Sep 17 00:00:00 2001
From: Tom Tromey
Date: Mon, 14 Feb 2011 08:39:19 -0700
Subject: Hide implementation of `struct buffer' 	* composite.c
 (fill_gstring_header) 	(composition_compute_stop_pos,
 composition_adjust_point) 	(Ffind_composition_internal): Use B_. 	*
 intervals.c (set_point_both, get_local_map): Use B_. 	* callproc.c
 (Fcall_process, Fcall_process_region): Use B_. 	* process.c
 (get_process, list_processes_1, Fstart_process) 	(Fmake_serial_process,
 Fmake_network_process) 	(read_process_output, send_process,
 exec_sentinel) 	(status_notify, setup_process_coding_systems): Use B_.
 	* bytecode.c (Fbyte_code): Use B_. 	* syntax.c
 (update_syntax_table, dec_bytepos, Fsyntax_table) 	(Fset_syntax_table,
 Fmodify_syntax_entry, skip_chars) 	(skip_syntaxes, scan_lists): Use B_. 
 * lread.c (readchar, unreadchar, openp, readevalloop) 	(Feval_buffer,
 Feval_region): Use B_. 	* print.c (printchar, strout, print_string,
 PRINTDECLARE) 	(PRINTPREPARE, PRINTFINISH, temp_output_buffer_setup) 
 (print_object): Use B_. 	* font.c (font_at): Use B_. 	* fns.c
 (Fbase64_encode_region, Fbase64_decode_region, Fmd5): Use 	B_. 	*
 callint.c (check_mark, Fcall_interactively): Use B_. 	* editfns.c
 (region_limit, Fmark_marker, save_excursion_save) 
 (save_excursion_restore, Fprevious_char, Fchar_before) 
 (general_insert_function, Finsert_char, Finsert_byte) 
 (make_buffer_string_both, Finsert_buffer_substring) 
 (Fcompare_buffer_substrings, subst_char_in_region_unwind) 
 (subst_char_in_region_unwind_1, Fsubst_char_in_region) 
 (Ftranslate_region_internal, save_restriction_restore) 	(Fchar_equal):
 Use B_. 	* data.c (swap_in_symval_forwarding, set_internal) 
 (Fmake_local_variable, Fkill_local_variable, Flocal_variable_p): 	Use
 B_. 	* undo.c (record_point, record_insert, record_delete) 
 (record_marker_adjustment, record_first_change) 
 (record_property_change, Fundo_boundary, truncate_undo_list) 
 (Fprimitive_undo): Use B_. 	* search.c (compile_pattern_1,
 compile_pattern, looking_at_1) 	(string_match_1, fast_looking_at,
 newline_cache_on_off) 	(search_command, search_buffer, simple_search,
 boyer_moore) 	(Freplace_match): Use B_. 	* indent.c
 (buffer_display_table, recompute_width_table) 	(width_run_cache_on_off,
 current_column, scan_for_column) 	(Findent_to, position_indentation,
 compute_motion, vmotion): Use 	B_. 	* casefiddle.c (casify_object,
 casify_region): Use B_. 	* casetab.c (Fcurrent_case_table,
 set_case_table): Use B_. 	* cmds.c (Fself_insert_command,
 internal_self_insert): Use B_. 	* fileio.c (Fexpand_file_name,
 Ffile_directory_p) 	(Ffile_regular_p, Ffile_selinux_context) 
 (Fset_file_selinux_context, Ffile_modes, Fset_file_modes) 
 (Fset_file_times, Ffile_newer_than_file_p, decide_coding_unwind) 
 (Finsert_file_contents, choose_write_coding_system) 	(Fwrite_region,
 build_annotations, Fverify_visited_file_modtime) 
 (Fset_visited_file_modtime, auto_save_error, auto_save_1) 
 (Fdo_auto_save, Fset_buffer_auto_saved): Use B_. 	* minibuf.c
 (read_minibuf, get_minibuffer, Fread_buffer): Use B_. 	* marker.c
 (Fmarker_buffer, Fset_marker, set_marker_restricted) 	(set_marker_both,
 set_marker_restricted_both, unchain_marker): Use 	B_. 	* insdel.c
 (check_markers, insert_char, insert_1_both) 	(insert_from_string_1,
 insert_from_gap, insert_from_buffer_1) 	(adjust_after_replace,
 replace_range, del_range_2) 	(modify_region, prepare_to_modify_buffer) 
 (Fcombine_after_change_execute): Use B_. 	* filelock.c
 (unlock_all_files, Flock_buffer, Funlock_buffer) 	(unlock_buffer): Use
 B_. 	* keymap.c (Flocal_key_binding, Fuse_local_map) 
 (Fcurrent_local_map, push_key_description) 	(Fdescribe_buffer_bindings):
 Use B_. 	* keyboard.c (command_loop_1, read_char_minibuf_menu_prompt) 
 (read_key_sequence): Use B_. 	* fringe.c (get_logical_cursor_bitmap) 
 (get_logical_fringe_bitmap, update_window_fringes): Use B_. 	* xfns.c
 (x_create_tip_frame, Fx_show_tip): Use B_. 	* xfaces.c
 (compute_char_face): Use B_. 	* character.c (chars_in_text, Fget_byte): Use
 B_. 	* category.c (check_category_table, Fcategory_table) 
 (Fset_category_table, char_category_set): Use B_. 	* coding.c
 (decode_coding, encode_coding) 	(make_conversion_work_buffer,
 decode_coding_gap) 	(decode_coding_object, encode_coding_object) 
 (Fdetect_coding_region, Ffind_coding_systems_region_internal) 
 (Funencodable_char_position, Fcheck_coding_systems_region): Use 	B_. 
 * charset.c (Ffind_charset_region): Use B_. 	* window.c
 (window_display_table, unshow_buffer, window_loop) 	(window_min_size_2,
 set_window_buffer, Fset_window_buffer) 	(select_window,
 Fforce_window_update, temp_output_buffer_show) 
 (Fset_window_configuration, save_window_save): Use B_. 	* xdisp.c
 (pos_visible_p, init_iterator, reseat_1) 	(message_dolog,
 update_echo_area, ensure_echo_area_buffers) 	(with_echo_area_buffer,
 setup_echo_area_for_printing) 	(set_message_1, update_menu_bar,
 update_tool_bar) 	(text_outside_line_unchanged_p, redisplay_internal) 
 (try_scrolling, try_cursor_movement, redisplay_window) 
 (try_window_reusing_current_matrix, row_containing_pos) 
 (try_window_id, get_overlay_arrow_glyph_row, display_line) 
 (Fcurrent_bidi_paragraph_direction, display_mode_lines) 
 (decode_mode_spec_coding, decode_mode_spec, display_count_lines) 
 (get_window_cursor_type, note_mouse_highlight): Use B_. 	* frame.c
 (make_frame_visible_1): Use B_. 	* dispnew.c
 (Fframe_or_buffer_changed_p): Use B_. 	* dispextern.h
 (WINDOW_WANTS_HEADER_LINE_P) 	(WINDOW_WANTS_MODELINE_P): Use B_. 	*
 syntax.h (Vstandard_syntax_table): Update. 	(CURRENT_SYNTAX_TABLE,
 SETUP_BUFFER_SYNTAX_TABLE): Use B_. 	* intervals.h
 (TEXT_PROP_MEANS_INVISIBLE): Update. 	(TEXT_PROP_MEANS_INVISIBLE): Use B_. 
 * character.h (FETCH_CHAR_ADVANCE): Update. 	(INC_BOTH, ASCII_CHAR_WIDTH,
 DEC_BOTH): Use B_. 	* category.h (Vstandard_category_table): Update. 
 * lisp.h (DEFVAR_BUFFER_DEFAULTS): Update for change to field 	names. 
 (DOWNCASE_TABLE, UPCASE_TABLE): Use B_. 	* buffer.c (swapfield_): New
 macro. 	(Fbuffer_swap_text): Use swapfield_ where appropriate. 
 (Fbuffer_live_p, Fget_file_buffer, get_truename_buffer) 
 (Fget_buffer_create, clone_per_buffer_values) 	(Fmake_indirect_buffer,
 reset_buffer) 	(reset_buffer_local_variables, Fbuffer_name,
 Fbuffer_file_name) 	(Fbuffer_local_value, buffer_lisp_local_variables) 
 (Fset_buffer_modified_p, Frestore_buffer_modified_p) 	(Frename_buffer,
 Fother_buffer, Fbuffer_enable_undo) 	(Fkill_buffer, Fset_buffer_major_mode,
 set_buffer_internal_1) 	(set_buffer_temp, Fset_buffer,
 set_buffer_if_live) 	(Fbarf_if_buffer_read_only, Fbury_buffer,
 Ferase_buffer) 	(Fbuffer_swap_text, Fset_buffer_multibyte) 
 (swap_out_buffer_local_variables, record_overlay_string) 
 (overlay_strings, init_buffer_once, init_buffer, syms_of_buffer): 	Use
 B_. 	* buffer.h (struct buffer): Rename all Lisp_Object fields. 
 (BUFFER_INTERNAL_FIELD, B_): New macro. 	(FETCH_CHAR,
 FETCH_CHAR_AS_MULTIBYTE): Use B_.

---
 src/bytecode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index fd2680e4054..a470eca16a9 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1398,7 +1398,7 @@ If the third argument is incorrect, Emacs may crash.  */)
 	    CHECK_CHARACTER (TOP);
 	    AFTER_POTENTIAL_GC ();
 	    c = XFASTINT (TOP);
-	    if (NILP (current_buffer->enable_multibyte_characters))
+	    if (NILP (B_ (current_buffer, enable_multibyte_characters)))
 	      MAKE_CHAR_MULTIBYTE (c);
 	    XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]);
 	  }
-- 
cgit v1.2.1


From 4b4deea229a39c94762dcf49da538b639df59148 Mon Sep 17 00:00:00 2001
From: Tom Tromey
Date: Wed, 16 Feb 2011 08:02:50 -0700
Subject: Change B_ to BVAR 	* xfns.c (x_create_tip_frame, Fx_show_tip):
 Replace B_ with BVAR. 	* xfaces.c (compute_char_face): Replace B_ with BVAR. 
 * xdisp.c (pos_visible_p, init_iterator, reseat_1) 	(message_dolog,
 update_echo_area, ensure_echo_area_buffers) 	(with_echo_area_buffer,
 setup_echo_area_for_printing) 	(set_message_1, update_menu_bar,
 update_tool_bar) 	(text_outside_line_unchanged_p, redisplay_internal) 
 (try_scrolling, try_cursor_movement, redisplay_window) 
 (try_window_reusing_current_matrix, row_containing_pos) 
 (try_window_id, get_overlay_arrow_glyph_row, display_line) 
 (Fcurrent_bidi_paragraph_direction, display_mode_lines) 
 (decode_mode_spec_coding, decode_mode_spec, display_count_lines) 
 (get_window_cursor_type, note_mouse_highlight): Replace B_ with 	BVAR. 
 * window.c (window_display_table, unshow_buffer, window_loop) 
 (window_min_size_2, set_window_buffer, Fset_window_buffer) 
 (select_window, Fforce_window_update, temp_output_buffer_show) 
 (Fset_window_configuration, save_window_save): Replace B_ with 	BVAR. 
 * w32fns.c (x_create_tip_frame, Fx_show_tip, Fw32_shell_execute): 
 Replace B_ with BVAR. 	* undo.c (record_point, record_insert, record_delete) 
 (record_marker_adjustment, record_first_change) 
 (record_property_change, Fundo_boundary, truncate_undo_list) 
 (Fprimitive_undo): Replace B_ with BVAR. 	* syntax.h
 (Vstandard_syntax_table, CURRENT_SYNTAX_TABLE) 
 (SETUP_BUFFER_SYNTAX_TABLE): Replace B_ with BVAR. 	* syntax.c
 (update_syntax_table, dec_bytepos, Fsyntax_table) 	(Fset_syntax_table,
 Fmodify_syntax_entry, skip_chars) 	(skip_syntaxes, scan_lists): Replace
 B_ with BVAR. 	* search.c (compile_pattern_1, compile_pattern, looking_at_1) 
 (string_match_1, fast_looking_at, newline_cache_on_off) 
 (search_command, search_buffer, simple_search, boyer_moore) 
 (Freplace_match): Replace B_ with BVAR. 	* process.c (get_process,
 list_processes_1, Fstart_process) 	(Fmake_serial_process,
 Fmake_network_process) 	(read_process_output, send_process,
 exec_sentinel) 	(status_notify, setup_process_coding_systems): Replace
 B_ with 	BVAR. 	* print.c (PRINTDECLARE, PRINTPREPARE, PRINTFINISH,
 printchar) 	(strout, print_string, temp_output_buffer_setup,
 print_object): 	Replace B_ with BVAR. 	* msdos.c
 (IT_frame_up_to_date): Replace B_ with BVAR. 	* minibuf.c (read_minibuf,
 get_minibuffer, Fread_buffer): Replace 	B_ with BVAR. 	* marker.c
 (Fmarker_buffer, Fset_marker, set_marker_restricted) 	(set_marker_both,
 set_marker_restricted_both, unchain_marker): 	Replace B_ with BVAR. 	*
 lread.c (readchar, unreadchar, openp, readevalloop) 	(Feval_buffer,
 Feval_region): Replace B_ with BVAR. 	* lisp.h (DOWNCASE_TABLE,
 UPCASE_TABLE): Replace B_ with BVAR. 	* keymap.c (Flocal_key_binding,
 Fuse_local_map) 	(Fcurrent_local_map, push_key_description) 
 (Fdescribe_buffer_bindings): Replace B_ with BVAR. 	* keyboard.c
 (command_loop_1, read_char_minibuf_menu_prompt) 	(read_key_sequence):
 Replace B_ with BVAR. 	* intervals.h (TEXT_PROP_MEANS_INVISIBLE): Replace B_
 with BVAR. 	* intervals.c (set_point_both, get_local_map): Replace B_ with
 	BVAR. 	* insdel.c (check_markers, insert_char, insert_1_both) 
 (insert_from_string_1, insert_from_gap, insert_from_buffer_1) 
 (adjust_after_replace, replace_range, del_range_2) 	(modify_region,
 prepare_to_modify_buffer) 	(Fcombine_after_change_execute): Replace B_
 with BVAR. 	* indent.c (buffer_display_table, recompute_width_table) 
 (width_run_cache_on_off, current_column, scan_for_column) 	(Findent_to,
 position_indentation, compute_motion, vmotion): 	Replace B_ with BVAR. 
 * fringe.c (get_logical_cursor_bitmap) 	(get_logical_fringe_bitmap,
 update_window_fringes): Replace B_ 	with BVAR. 	* frame.c
 (make_frame_visible_1): Replace B_ with BVAR. 	* font.c (font_at): Replace B_
 with BVAR. 	* fns.c (Fbase64_encode_region, Fbase64_decode_region, Fmd5): 
 Replace B_ with BVAR. 	* filelock.c (unlock_all_files, Flock_buffer,
 Funlock_buffer) 	(unlock_buffer): Replace B_ with BVAR. 	* fileio.c
 (Fexpand_file_name, Ffile_directory_p) 	(Ffile_regular_p,
 Ffile_selinux_context) 	(Fset_file_selinux_context, Ffile_modes,
 Fset_file_modes) 	(Fset_file_times, Ffile_newer_than_file_p,
 decide_coding_unwind) 	(Finsert_file_contents, choose_write_coding_system) 
 (Fwrite_region, build_annotations, Fverify_visited_file_modtime) 
 (Fset_visited_file_modtime, auto_save_error, auto_save_1) 
 (Fdo_auto_save, Fset_buffer_auto_saved): Replace B_ with BVAR. 	*
 editfns.c (region_limit, Fmark_marker, save_excursion_save) 
 (save_excursion_restore, Fprevious_char, Fchar_before) 
 (general_insert_function, Finsert_char, Finsert_byte) 
 (make_buffer_string_both, Finsert_buffer_substring) 
 (Fcompare_buffer_substrings, subst_char_in_region_unwind) 
 (subst_char_in_region_unwind_1, Fsubst_char_in_region) 
 (Ftranslate_region_internal, save_restriction_restore) 	(Fchar_equal):
 Replace B_ with BVAR. 	* dispnew.c (Fframe_or_buffer_changed_p): Replace B_
 with BVAR. 	* dispextern.h (WINDOW_WANTS_MODELINE_P) 
 (WINDOW_WANTS_HEADER_LINE_P): Replace B_ with BVAR. 	* dired.c
 (directory_files_internal): Replace B_ with BVAR. 	* data.c
 (swap_in_symval_forwarding, set_internal) 	(Fmake_local_variable,
 Fkill_local_variable, Flocal_variable_p): 	Replace B_ with BVAR. 	*
 composite.c (fill_gstring_header) 	(composition_compute_stop_pos,
 composition_adjust_point) 	(Ffind_composition_internal): Replace B_ with
 BVAR. 	* coding.c (decode_coding, encode_coding) 
 (make_conversion_work_buffer, decode_coding_gap) 	(decode_coding_object,
 encode_coding_object) 	(Fdetect_coding_region,
 Ffind_coding_systems_region_internal) 	(Funencodable_char_position,
 Fcheck_coding_systems_region): 	Replace B_ with BVAR. 	* cmds.c
 (Fself_insert_command, internal_self_insert): Replace B_ 	with BVAR. 
 * charset.c (Ffind_charset_region): Replace B_ with BVAR. 	* character.h
 (FETCH_CHAR_ADVANCE, INC_BOTH, DEC_BOTH) 	(ASCII_CHAR_WIDTH): Replace B_
 with BVAR. 	* character.c (chars_in_text, Fget_byte): Replace B_ with
 BVAR. 	* category.h (Vstandard_category_table): Replace B_ with BVAR. 	*
 category.c (check_category_table, Fcategory_table) 	(Fset_category_table,
 char_category_set): Replace B_ with BVAR. 	* casetab.c
 (Fcurrent_case_table, set_case_table): Replace B_ with 	BVAR. 	*
 casefiddle.c (casify_object, casify_region): Replace B_ with 	BVAR. 	*
 callproc.c (Fcall_process, Fcall_process_region): Replace B_ 	with BVAR. 
 * callint.c (check_mark, Fcall_interactively): Replace B_ with 	BVAR. 
 * bytecode.c (Fbyte_code): Replace B_ with BVAR. 	* buffer.h
 (FETCH_CHAR, FETCH_CHAR_AS_MULTIBYTE, BVAR): Replace B_ 	with BVAR. 
 * buffer.c (Fbuffer_live_p, Fget_file_buffer) 	(get_truename_buffer,
 Fget_buffer_create) 	(clone_per_buffer_values, Fmake_indirect_buffer,
 reset_buffer) 	(reset_buffer_local_variables, Fbuffer_name,
 Fbuffer_file_name) 	(Fbuffer_local_value, buffer_lisp_local_variables) 
 (Fset_buffer_modified_p, Frestore_buffer_modified_p) 	(Frename_buffer,
 Fother_buffer, Fbuffer_enable_undo) 	(Fkill_buffer, Fset_buffer_major_mode,
 set_buffer_internal_1) 	(set_buffer_temp, Fset_buffer,
 set_buffer_if_live) 	(Fbarf_if_buffer_read_only, Fbury_buffer,
 Ferase_buffer) 	(Fbuffer_swap_text, swapfield_, Fbuffer_swap_text) 
 (Fset_buffer_multibyte, swap_out_buffer_local_variables) 
 (record_overlay_string, overlay_strings, init_buffer_once) 	(init_buffer,
 syms_of_buffer): Replace B_ with BVAR.

---
 src/bytecode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index a470eca16a9..a88df080c5a 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1398,7 +1398,7 @@ If the third argument is incorrect, Emacs may crash.  */)
 	    CHECK_CHARACTER (TOP);
 	    AFTER_POTENTIAL_GC ();
 	    c = XFASTINT (TOP);
-	    if (NILP (B_ (current_buffer, enable_multibyte_characters)))
+	    if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
 	      MAKE_CHAR_MULTIBYTE (c);
 	    XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]);
 	  }
-- 
cgit v1.2.1


From b38b1ec071ee9752da53f2485902165fe728e8fa Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Thu, 17 Feb 2011 16:19:13 -0500
Subject: Various compiler bug-fixes.  MPC seems to run correctly now. *
 lisp/files.el (lexical-binding): Add a safe-local-variable property.

* lisp/emacs-lisp/byte-opt.el (byte-inline-lapcode): Check how many elements
are added to the stack.
(byte-compile-splice-in-already-compiled-code): Don't touch lexical nor
byte-compile-depth now that byte-inline-lapcode does it for us.
(byte-compile-inline-expand): Don't inline dynbind byte code into
lexbind code, since it has to be done differently.

* lisp/emacs-lisp/bytecomp.el (byte-compile-arglist-warn):
Correctly extract arglist from `closure's.
(byte-compile-cl-warn): Compiler-macros are run earlier now.
(byte-compile-top-level): Bind byte-compile-lexical-environment to nil,
except for lambdas.
(byte-compile-form): Don't run the compiler-macro expander here.
(byte-compile-let): Merge with byte-compile-let*.
Don't preserve-body-value if the body's value was discarded.

* lisp/emacs-lisp/cconv.el (cconv--set-diff, cconv--set-diff-map)
(cconv--map-diff, cconv--map-diff-elem, cconv--map-diff-set): New funs.
(cconv--env-var): New constant.
(cconv-closure-convert-rec): Use it and use them.  Fix a typo that
ended up forgetting to remove entries from lmenvs in `let'.
For `lambda' use the outer `fvrs' when building the closure and don't
forget to remove `vars' from the `emvrs' and `lmenvs' of the body.

* lisp/emacs-lisp/cl-macs.el (cl-byte-compile-block): Disable optimization
in lexbind, because it needs a different implementation.

* src/bytecode.c (exec_byte_code): Fix handling of &rest.

* src/eval.c (Vinternal_interpreter_environment): Remove.
(syms_of_eval): Do declare Vinternal_interpreter_environment as
a global lisp var, but unintern it to hide it.
(Fcommandp):
* src/data.c (Finteractive_form): Understand `closure's.
---
 src/bytecode.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 9bf6ae45ce9..1ad01aaf8f7 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -500,7 +500,9 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	  optional = 1;
 	else if (EQ (XCAR (at), Qand_rest))
 	  {
-	    PUSH (Flist (nargs, args));
+	    PUSH (pushed < nargs
+		  ? Flist (nargs - pushed, args)
+		  : Qnil);
 	    pushed = nargs;
 	    at = Qnil;
 	    break;
-- 
cgit v1.2.1


From b286858c7a0d5dafa302b9e88970c13385358a6a Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Thu, 17 Feb 2011 21:07:36 -0500
Subject: Don't GC-scan stack data redundantly. * src/alloc.c
 (Fgarbage_collect): When using stack scanning, don't redundantly scan
 byte-code stacks, catchlist, and handlerlist. * src/bytecode.c
 (BYTE_MAINTAIN_TOP): New macros. (struct byte_stack): Only define `top' and
 `bottom' if used. (mark_byte_stack): Only define if used.
 (BEFORE_POTENTIAL_GC, AFTER_POTENTIAL_GC): Nullify if BYTE_MAINTAIN_TOP is
 not set. (Fbyte_code): Don't set `bottom' unless BYTE_MAINTAIN_TOP is set. *
 src/lisp.h (BYTE_MARK_STACK): New macro. (mark_byte_stack): Only declare if
 BYTE_MARK_STACK is set. * src/term.c (OUTPUT_IF): Use OUTPUT.

---
 src/bytecode.c | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index a88df080c5a..cf4a1fc225f 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -229,6 +229,8 @@ Lisp_Object Qbytecode;
 #define Bconstant 0300
 #define CONSTANTLIM 0100
 
+/* Whether to maintain a `top' and `bottom' field in the stack frame.  */
+#define BYTE_MAINTAIN_TOP (BYTE_CODE_SAFE || BYTE_MARK_STACK)
 
 /* Structure describing a value stack used during byte-code execution
    in Fbyte_code.  */
@@ -241,7 +243,9 @@ struct byte_stack
 
   /* Top and bottom of stack.  The bottom points to an area of memory
      allocated with alloca in Fbyte_code.  */
+#if BYTE_MAINTAIN_TOP
   Lisp_Object *top, *bottom;
+#endif
 
   /* The string containing the byte-code, and its current address.
      Storing this here protects it from GC because mark_byte_stack
@@ -268,6 +272,7 @@ struct byte_stack *byte_stack_list;
 
 /* Mark objects on byte_stack_list.  Called during GC.  */
 
+#if BYTE_MARK_STACK
 void
 mark_byte_stack (void)
 {
@@ -292,7 +297,7 @@ mark_byte_stack (void)
       mark_object (stack->constants);
     }
 }
-
+#endif
 
 /* Unmark objects in the stacks on byte_stack_list.  Relocate program
    counters.  Called when GC has completed.  */
@@ -346,8 +351,13 @@ unmark_byte_stack (void)
 /* Actions that must be performed before and after calling a function
    that might GC.  */
 
+#if !BYTE_MAINTAIN_TOP
+#define BEFORE_POTENTIAL_GC()	((void)0)
+#define AFTER_POTENTIAL_GC()	((void)0)
+#else
 #define BEFORE_POTENTIAL_GC()	stack.top = top
 #define AFTER_POTENTIAL_GC()	stack.top = NULL
+#endif
 
 /* Garbage collect if we have consed enough since the last time.
    We do this at every branch, to avoid loops that never GC.  */
@@ -447,10 +457,13 @@ If the third argument is incorrect, Emacs may crash.  */)
   stack.byte_string = bytestr;
   stack.pc = stack.byte_string_start = SDATA (bytestr);
   stack.constants = vector;
-  stack.bottom = (Lisp_Object *) alloca (XFASTINT (maxdepth)
+  top = (Lisp_Object *) alloca (XFASTINT (maxdepth)
                                          * sizeof (Lisp_Object));
-  top = stack.bottom - 1;
+#if BYTE_MAINTAIN_TOP
+  stack.bottom = top;
   stack.top = NULL;
+#endif
+  top -= 1;
   stack.next = byte_stack_list;
   byte_stack_list = &stack;
 
-- 
cgit v1.2.1


From e0f57e65692ed73a86926f737388b60faec92767 Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Sat, 19 Feb 2011 00:10:33 -0500
Subject: * lisp/subr.el (save-window-excursion): New macro, moved from C. *
 lisp/emacs-lisp/lisp-mode.el (save-window-excursion): Don't touch. *
 lisp/emacs-lisp/cconv.el (cconv-closure-convert-rec, cconv-analyse-form):
 Don't handle save-window-excursion any more. * lisp/emacs-lisp/bytecomp.el
 (interactive-p, save-window-excursion): Don't use the byte-code any more.
 (byte-compile-form): Check macro expansion was done.
 (byte-compile-save-window-excursion): Remove. * lisp/emacs-lisp/byte-opt.el
 (byte-optimize-form-code-walker): Ignore save-window-excursion.  Don't
 macroepand any more.

* src/window.c (Fsave_window_excursion): Remove.  Moved to Lisp.
(syms_of_window): Don't defsubr it.
* src/window.h (Fsave_window_excursion): Don't declare it.
* src/bytecode.c (exec_byte_code): Inline Fsave_window_excursion.
---
 src/bytecode.c | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 1ad01aaf8f7..ad2f7d18ade 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -138,7 +138,7 @@ extern Lisp_Object Qand_optional, Qand_rest;
 
 #define Bpoint 0140
 /* Was Bmark in v17.  */
-#define Bsave_current_buffer 0141
+#define Bsave_current_buffer 0141 /* Obsolete.  */
 #define Bgoto_char 0142
 #define Binsert 0143
 #define Bpoint_max 0144
@@ -158,7 +158,7 @@ extern Lisp_Object Qand_optional, Qand_rest;
 #define Bsave_current_buffer_1 0162 /* Replacing Bsave_current_buffer.  */
 #define Bread_char 0162 /* No longer generated as of v19 */
 #define Bset_mark 0163 /* this loser is no longer generated as of v18 */
-#define Binteractive_p 0164 /* Needed since interactive-p takes unevalled args */
+#define Binteractive_p 0164 /* Obsolete.  */
 
 #define Bforward_char 0165
 #define Bforward_word 0166
@@ -183,7 +183,7 @@ extern Lisp_Object Qand_optional, Qand_rest;
 #define Bdup 0211
 
 #define Bsave_excursion 0212
-#define Bsave_window_excursion 0213
+#define Bsave_window_excursion 0213 /* Obsolete.  */
 #define Bsave_restriction 0214
 #define Bcatch 0215
 
@@ -192,7 +192,7 @@ extern Lisp_Object Qand_optional, Qand_rest;
 #define Btemp_output_buffer_setup 0220
 #define Btemp_output_buffer_show 0221
 
-#define Bunbind_all 0222
+#define Bunbind_all 0222	/* Obsolete.  */
 
 #define Bset_marker 0223
 #define Bmatch_beginning 0224
@@ -763,7 +763,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	  AFTER_POTENTIAL_GC ();
 	  break;
 
-	case Bunbind_all:
+	case Bunbind_all:	/* Obsolete.  */
 	  /* To unbind back to the beginning of this frame.  Not used yet,
 	     but will be needed for tail-recursion elimination.  */
 	  BEFORE_POTENTIAL_GC ();
@@ -891,16 +891,24 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 				 save_excursion_save ());
 	  break;
 
-	case Bsave_current_buffer:
+	case Bsave_current_buffer: /* Obsolete.  */
 	case Bsave_current_buffer_1:
 	  record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
 	  break;
 
-	case Bsave_window_excursion:
-	  BEFORE_POTENTIAL_GC ();
-	  TOP = Fsave_window_excursion (TOP); /* FIXME: lexbind */
-	  AFTER_POTENTIAL_GC ();
-	  break;
+	case Bsave_window_excursion: /* Obsolete.  */
+	  {
+	    register Lisp_Object val;
+	    register int count = SPECPDL_INDEX ();
+
+	    record_unwind_protect (Fset_window_configuration,
+				   Fcurrent_window_configuration (Qnil));
+	    BEFORE_POTENTIAL_GC ();
+	    TOP = Fprogn (TOP);
+	    unbind_to (count, TOP);
+	    AFTER_POTENTIAL_GC ();
+	    break;
+	  }
 
 	case Bsave_restriction:
 	  record_unwind_protect (save_restriction_restore,
@@ -1412,7 +1420,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	  AFTER_POTENTIAL_GC ();
 	  break;
 
-	case Binteractive_p:
+	case Binteractive_p:	/* Obsolete.  */
 	  PUSH (Finteractive_p ());
 	  break;
 
-- 
cgit v1.2.1


From 3e21b6a72b87787e2327513a44623b250054f77d Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Mon, 21 Feb 2011 15:12:44 -0500
Subject: Use offsets relative to top rather than bottom for stack refs *
 lisp/emacs-lisp/byte-opt.el (byte-compile-side-effect-and-error-free-ops):
 Remove interactive-p. (byte-optimize-lapcode): Update optimizations now that
 stack-refs are relative to the top rather than to the bottom. *
 lisp/emacs-lisp/bytecomp.el (byte-compile-lapcode): Turn stack-ref-0 into
 dup. (byte-compile-form): Don't indirect-function since it can signal errors.
 (byte-compile-stack-ref, byte-compile-stack-set): Adjust to stack-refs being
 relative to top rather than to bottom in the byte-code.
 (with-output-to-temp-buffer): Remove.
 (byte-compile-with-output-to-temp-buffer): Remove. *
 lisp/emacs-lisp/cconv.el: Use lexical-binding. (cconv--lookup-let): Rename
 from cconv-lookup-let. (cconv-closure-convert-rec): Fix handling of
 captured+mutated arguments in defun/defmacro. * lisp/emacs-lisp/eieio-comp.el
 (eieio-byte-compile-file-form-defmethod): Rename from
 byte-compile-file-form-defmethod. Don't byte-compile-lambda.
 (eieio-byte-compile-defmethod-param-convert): Rename from
 byte-compile-defmethod-param-convert. * lisp/emacs-lisp/eieio.el
 (eieio-defgeneric-form-primary-only-one): Call byte-compile rather than
 byte-compile-lambda. * src/alloc.c (Fgarbage_collect): Don't mark the
 byte-stack redundantly. * src/bytecode.c (exec_byte_code): Change stack_ref
 and stack_set to use offsets relative to top rather than to bottom. *
 lisp/subr.el (with-output-to-temp-buffer): New macro. * lisp/simple.el
 (count-words-region): Don't use interactive-p.

---
 src/bytecode.c | 52 +++++++++++++++++++++++++++++++++-------------------
 1 file changed, 33 insertions(+), 19 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index ad2f7d18ade..b2e9e3c5b56 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -51,7 +51,7 @@ by Hallvard:
  *
  * define BYTE_CODE_METER to enable generation of a byte-op usage histogram.
  */
-/* #define BYTE_CODE_SAFE */
+#define BYTE_CODE_SAFE
 /* #define BYTE_CODE_METER */
 
 
@@ -88,7 +88,7 @@ extern Lisp_Object Qand_optional, Qand_rest;
 
 /*  Byte codes: */
 
-#define Bstack_ref 0
+#define Bstack_ref 0 /* Actually, Bstack_ref+0 is not implemented: use dup.  */
 #define Bvarref 010
 #define Bvarset 020
 #define Bvarbind 030
@@ -189,8 +189,8 @@ extern Lisp_Object Qand_optional, Qand_rest;
 
 #define Bunwind_protect 0216
 #define Bcondition_case 0217
-#define Btemp_output_buffer_setup 0220
-#define Btemp_output_buffer_show 0221
+#define Btemp_output_buffer_setup 0220 /* Obsolete.  */
+#define Btemp_output_buffer_show 0221  /* Obsolete.  */
 
 #define Bunbind_all 0222	/* Obsolete.  */
 
@@ -898,9 +898,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 
 	case Bsave_window_excursion: /* Obsolete.  */
 	  {
-	    register Lisp_Object val;
 	    register int count = SPECPDL_INDEX ();
-
 	    record_unwind_protect (Fset_window_configuration,
 				   Fcurrent_window_configuration (Qnil));
 	    BEFORE_POTENTIAL_GC ();
@@ -940,7 +938,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	    break;
 	  }
 
-	case Btemp_output_buffer_setup:
+	case Btemp_output_buffer_setup: /* Obsolete.  */
 	  BEFORE_POTENTIAL_GC ();
 	  CHECK_STRING (TOP);
 	  temp_output_buffer_setup (SSDATA (TOP));
@@ -948,7 +946,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	  TOP = Vstandard_output;
 	  break;
 
-	case Btemp_output_buffer_show:
+	case Btemp_output_buffer_show: /* Obsolete.  */
 	  {
 	    Lisp_Object v1;
 	    BEFORE_POTENTIAL_GC ();
@@ -1710,26 +1708,42 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 #endif
 
 	  /* Handy byte-codes for lexical binding.  */
-	case Bstack_ref:
+	  /* case Bstack_ref: */  /* Use `dup' instead.  */
 	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;
+	  {
+	    Lisp_Object *ptr = top - (op - Bstack_ref);
+	    PUSH (*ptr);
+	    break;
+	  }
 	case Bstack_ref+6:
-	  PUSH (stack.bottom[FETCH]);
-	  break;
+	  {
+	    Lisp_Object *ptr = top - (FETCH);
+	    PUSH (*ptr);
+	    break;
+	  }
 	case Bstack_ref+7:
-	  PUSH (stack.bottom[FETCH2]);
-	  break;
+	  {
+	    Lisp_Object *ptr = top - (FETCH2);
+	    PUSH (*ptr);
+	    break;
+	  }
+	  /* stack-set-0 = discard; stack-set-1 = discard-1-preserve-tos.  */
 	case Bstack_set:
-	  stack.bottom[FETCH] = POP;
-	  break;
+	  {
+	    Lisp_Object *ptr = top - (FETCH);
+	    *ptr = POP;
+	    break;
+	  }
 	case Bstack_set2:
-	  stack.bottom[FETCH2] = POP;
-	  break;
+	  {
+	    Lisp_Object *ptr = top - (FETCH2);
+	    *ptr = POP;
+	    break;
+	  }
 	case BdiscardN:
 	  op = FETCH;
 	  if (op & 0x80)
-- 
cgit v1.2.1


From 876c194cbac17a6220dbf406b0a602325978011c Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Thu, 24 Feb 2011 22:27:45 -0500
Subject: Get rid of funvec. * lisp/emacs-lisp/bytecomp.el
 (byte-compile-lapcode): Handle new form of `byte-constant'.
 (byte-compile-close-variables, displaying-byte-compile-warnings): Add edebug
 spec. (byte-compile-toplevel-file-form): New fun, split out of
 byte-compile-file-form. (byte-compile-from-buffer): Use it to avoid applying
 cconv multiple times. (byte-compile): Only strip `function' if it's present.
 (byte-compile-lambda): Add `reserved-csts' argument. Use new lexenv arg of
 byte-compile-top-level. (byte-compile-reserved-constants): New var.
 (byte-compile-constants-vector): Obey it. (byte-compile-constants-vector):
 Handle new `byte-constant' form. (byte-compile-top-level): Add args `lexenv'
 and `reserved-csts'. (byte-compile-form): Don't check callargs here.
 (byte-compile-normal-call): Do it here instead.
 (byte-compile-push-unknown-constant) (byte-compile-resolve-unknown-constant):
 Remove, unused. (byte-compile-make-closure): Use `make-byte-code' rather than
 `curry', putting the environment into the "constant" pool.
 (byte-compile-get-closed-var): Use special byte-constant. *
 lisp/emacs-lisp/byte-opt.el (byte-optimize-form-code-walker): Handle new
 intermediate special form `internal-make-vector'. (byte-optimize-lapcode):
 Handle new form of `byte-constant'. * lisp/help-fns.el (describe-function-1):
 Don't handle funvecs. * lisp/emacs-lisp/macroexp.el (macroexpand-all-1): Only
 convert quote to function if the content is a lambda expression, not if it's
 a closure. * emacs-lisp/eieio-come.el: Remove. * lisp/emacs-lisp/eieio.el:
 Don't require eieio-comp. (defmethod): Do a bit more work to find the body
 and wrap it into a function before passing it to eieio-defmethod.
 (eieio-defmethod): New arg `code' for it. * lisp/emacs-lisp/debug.el
 (debugger-setup-buffer): Don't hide things in debugger backtrace. *
 lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Use backquotes, and be more
 careful when quoting a function value. * lisp/emacs-lisp/cconv.el
 (cconv-freevars): Accept defvar/defconst. (cconv-closure-convert-rec): Catch
 stray `internal-make-closure'. * lisp/Makefile.in (COMPILE_FIRST): Compile
 pcase and cconv early.

* src/eval.c (Qcurry): Remove.
(funcall_funvec): Remove.
(funcall_lambda): Move new byte-code handling to reduce impact.
Treat all args as lexical in the case of lexbind.
(Fcurry): Remove.
* src/data.c (Qfunction_vector): Remove.
(Ffunvecp): Remove.
* src/lread.c (read1): Revert to calling make_byte_code here.
(read_vector): Don't call make_byte_code any more.
* src/lisp.h (enum pvec_type): Rename back to PVEC_COMPILED.
(XSETCOMPILED): Rename back from XSETFUNVEC.
(FUNVEC_SIZE): Remove.
(FUNVEC_COMPILED_TAG_P, FUNVEC_COMPILED_P): Remove.
(COMPILEDP): Rename back from FUNVECP.
* src/fns.c (Felt): Remove unexplained FUNVEC check.
* src/doc.c (Fdocumentation): Don't handle funvec.
* src/alloc.c (make_funvec, Ffunvec): Remove.
* doc/lispref/vol2.texi (Top):
* doc/lispref/vol1.texi (Top):
* doc/lispref/objects.texi (Programming Types, Funvec Type, Type Predicates):
* doc/lispref/functions.texi (Functions, What Is a Function, FunctionCurrying):
* doc/lispref/elisp.texi (Top): Remove mentions of funvec and curry.
---
 src/bytecode.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 639c543dbf9..464bc3d12de 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -51,7 +51,7 @@ by Hallvard:
  *
  * define BYTE_CODE_METER to enable generation of a byte-op usage histogram.
  */
-/* #define BYTE_CODE_SAFE  1 */
+/* #define BYTE_CODE_SAFE */
 /* #define BYTE_CODE_METER */
 
 
@@ -1720,8 +1720,13 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	  break;
 #endif
 
+	case 0:
+	  /* Actually this is Bstack_ref with offset 0, but we use Bdup
+	     for that instead.  */
+	  /* case Bstack_ref: */
+	  abort ();
+
 	  /* Handy byte-codes for lexical binding.  */
-	  /* case Bstack_ref: */  /* Use `dup' instead.  */
 	case Bstack_ref+1:
 	case Bstack_ref+2:
 	case Bstack_ref+3:
-- 
cgit v1.2.1


From a9de04fa62f123413d82b7b7b1e7a77705eb82dd Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Sat, 26 Feb 2011 10:19:08 -0500
Subject: Compute freevars in cconv-analyse. * lisp/emacs-lisp/cconv.el:
 Compute freevars in cconv-analyse. (cconv-mutated, cconv-captured): Remove.
 (cconv-captured+mutated, cconv-lambda-candidates): Don't give them a global
 value. (cconv-freevars-alist): New var. (cconv-freevars): Remove.
 (cconv--lookup-let): Remove. (cconv-closure-convert-function): Extract from
 cconv-closure-convert-rec. (cconv-closure-convert-rec): Adjust to above
 changes. (fboundp): New function. (cconv-analyse-function, form): Rewrite. *
 lisp/emacs-lisp/bytecomp.el (byte-compile-initial-macro-environment): Handle
 declare-function here. (byte-compile-obsolete): Remove.
 (byte-compile-arglist-warn): Check late defsubst here.
 (byte-compile-file-form): Simplify. (byte-compile-file-form-defsubst):
 Remove. (byte-compile-macroexpand-declare-function): Rename from
 byte-compile-declare-function, turn it into a macro-expander.
 (byte-compile-normal-call): Check obsolescence. (byte-compile-quote-form):
 Remove. (byte-compile-defmacro): Revert to trunk's definition which seems to
 work just as well and handles `declare'. * lisp/emacs-lisp/byte-run.el
 (make-obsolete): Don't modify byte-compile. * lisp/Makefile.in
 (BIG_STACK_DEPTH): Increase to 1200. (compile-onefile): Pass
 $(BIG_STACK_OPTS) before "-l bytecomp". * lisp/emacs-lisp/macroexp.el: Use
 lexbind. (macroexpand-all-1): Check macro obsolescence. *
 lisp/vc/diff-mode.el: Use lexbind. * lisp/follow.el (follow-calc-win-end):
 Simplify.

---
 src/bytecode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 464bc3d12de..9693a5a9196 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -51,7 +51,7 @@ by Hallvard:
  *
  * define BYTE_CODE_METER to enable generation of a byte-op usage histogram.
  */
-/* #define BYTE_CODE_SAFE */
+#define BYTE_CODE_SAFE 1
 /* #define BYTE_CODE_METER */
 
 
-- 
cgit v1.2.1


From e2abe5a13dffb08d6371b6a611bc39c3a9ac2bc6 Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Sat, 5 Mar 2011 23:48:17 -0500
Subject: Fix pcase memoizing; change lexbound byte-code marker. *
 src/bytecode.c (exec_byte_code): Remove old lexical binding slot handling and
 replace it with the a integer args-desc handling. * eval.c (funcall_lambda):
 Adjust arglist test accordingly. * lisp/emacs-lisp/bytecomp.el
 (byte-compile-arglist-signature): Handle integer arglist descriptor.
 (byte-compile-make-args-desc): Make integer arglist descriptor.
 (byte-compile-lambda): Use integer arglist descriptor to mark lexical
 byte-coded functions instead of an extra slot. * lisp/help-fns.el
 (help-add-fundoc-usage): Don't add a dummy doc. (help-split-fundoc): Return a
 nil doc if there was no actual doc. (help-function-arglist): Generate an
 arglist from an integer arg-desc. * lisp/emacs-lisp/pcase.el
 (pcase--memoize): Rename from pcase-memoize; Make only the key weak. (pcase):
 Change the key used in the memoization table, so it does not always get GC'd
 away. * lisp/emacs-lisp/macroexp.el (macroexpand-all-1): Slight change to the
 pcase pattern to generate slightly better code.

---
 src/bytecode.c | 71 ++++++++++++++++++++++++++++++++++------------------------
 1 file changed, 42 insertions(+), 29 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 9693a5a9196..dbab02886e2 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -502,37 +502,50 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   stacke = stack.bottom - 1 + XFASTINT (maxdepth);
 #endif
 
-  if (! NILP (args_template))
-    /* We should push some arguments on the stack.  */
+  if (INTEGERP (args_template))
     {
-      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 (pushed < nargs
-		  ? Flist (nargs - pushed, args)
-		  : Qnil);
-	    pushed = nargs;
-	    at = Qnil;
-	    break;
-	  }
-	else if (pushed < nargs)
-	  {
-	    PUSH (*args++);
-	    pushed++;
-	  }
-	else if (optional)
-	  PUSH (Qnil);
-	else
-	  break;
-
-      if (pushed != nargs || !NILP (at))
+      int at = XINT (args_template);
+      int rest = at & 128;
+      int mandatory = at & 127;
+      int nonrest = at >> 8;
+      eassert (mandatory <= nonrest);
+      if (nargs <= nonrest)
+	{
+	  int i;
+	  for (i = 0 ; i < nargs; i++, args++)
+	    PUSH (*args);
+	  if (nargs < mandatory)
+	    /* Too few arguments.  */
+	    Fsignal (Qwrong_number_of_arguments,
+		     Fcons (Fcons (make_number (mandatory),
+				   rest ? Qand_rest : make_number (nonrest)),
+			    Fcons (make_number (nargs), Qnil)));
+	  else
+	    {
+	      for (; i < nonrest; i++)
+		PUSH (Qnil);
+	      if (rest)
+		PUSH (Qnil);
+	    }
+	}
+      else if (rest)
+	{
+	  int i;
+	  for (i = 0 ; i < nonrest; i++, args++)
+	    PUSH (*args);
+	  PUSH (Flist (nargs - nonrest, args));
+	}
+      else
+	/* Too many arguments.  */
 	Fsignal (Qwrong_number_of_arguments,
-		 Fcons (args_template, Fcons (make_number (nargs), Qnil)));
+		 Fcons (Fcons (make_number (mandatory),
+			       make_number (nonrest)),
+			Fcons (make_number (nargs), Qnil)));
+    }
+  else if (! NILP (args_template))
+    /* We should push some arguments on the stack.  */
+    {
+      error ("Unknown args template!");
     }
 
   while (1)
-- 
cgit v1.2.1


From 7831777b8a9e8d2f68bd17058359ea8849d66f70 Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Sun, 6 Mar 2011 02:27:06 -0800
Subject: current_column: Now returns EMACS_INT, fixing some iftc.

* bytecode.c (Fbyte_code): Don't cast current_column () to int.
* cmds.c (internal_self_insert): Likewise.
* indent.c (Fcurrent_column): Likewise.
* keymap.c (describe_command): Likewise.
* minibuf.c (read_minibuf): Likewise.
* indent.c (Fcurrent_indentation): Don't cast position_indentation ()
to int.
* xdisp.c (redisplay_internal, redisplay_window, decode_mode_spec):
Likewise.
* cmds.c (internal_self_insert): Declare locals to be EMACS_INT,
not int or double, if they might contain a column number.
* indent.c (current_column, Findent_to, indented_beyond_p):
(compute_motion, vmotion): Likewise.
* keymap.c (describe_command): Likewise.
* xdisp.c (pint2str): Likewise.
* indent.c (last_known_column): Now EMACS_INT, not int.
* minibuf.c (minibuf_prompt_width): Likewise.
* indent.c (current_column, current_column_1, position_indentation):
Return EMACS_INT, not double.
* lisp.h (current_column): Likewise.
* indent.c (indented_beyond_p): Last arg is now EMACS_INT, not double.
All callers changed.
* lisp.h (indented_beyond_p): Likewise.
---
 src/bytecode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index cf4a1fc225f..bb4e87c019d 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1323,7 +1323,7 @@ If the third argument is incorrect, Emacs may crash.  */)
 	  {
 	    Lisp_Object v1;
 	    BEFORE_POTENTIAL_GC ();
-	    XSETFASTINT (v1, (int) current_column ()); /* iftc */
+	    XSETFASTINT (v1, current_column ());
 	    AFTER_POTENTIAL_GC ();
 	    PUSH (v1);
 	    break;
-- 
cgit v1.2.1


From ca1055060d5793e368c1a165c412944d6800c3a6 Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Wed, 16 Mar 2011 16:08:39 -0400
Subject: Remove bytecomp- prefix, plus misc changes. *
 lisp/emacs-lisp/byte-opt.el (byte-compile-inline-expand): Make it work to
 inline lexbind interpreted functions into lexbind code. (bytedecomp-bytes):
 Not a dynamic var any more. (disassemble-offset): Get the bytes via an
 argument instead. (byte-decompile-bytecode-1): Use push. *
 lisp/emacs-lisp/bytecomp.el: Remove the bytecomp- prefix now that we use
 lexical-binding. (byte-compile-outbuffer): Rename from bytecomp-outbuffer. *
 lisp/emacs-lisp/cl-macs.el (load-time-value): * lisp/emacs-lisp/cl.el
 (cl-compiling-file): Adjust to new name. * lisp/emacs-lisp/pcase.el
 (pcase-mutually-exclusive-predicates): Add byte-code-function-p. (pcase--u1):
 Remove left-over code from early development. Fix case of variable shadowing
 in guards and predicates. (pcase--u1): Add a new `let' pattern. * src/image.c
 (parse_image_spec): Use Ffunctionp. * src/lisp.h: Declare Ffunctionp.

---
 src/bytecode.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index b19f9687cdc..ba3c012bd1a 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -939,27 +939,27 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 				 save_restriction_save ());
 	  break;
 
-	case Bcatch:
+	case Bcatch:		/* FIXME: ill-suited for lexbind */
 	  {
 	    Lisp_Object v1;
 	    BEFORE_POTENTIAL_GC ();
 	    v1 = POP;
-	    TOP = internal_catch (TOP, eval_sub, v1); /* FIXME: lexbind */
+	    TOP = internal_catch (TOP, eval_sub, v1);
 	    AFTER_POTENTIAL_GC ();
 	    break;
 	  }
 
-	case Bunwind_protect:
-	  record_unwind_protect (Fprogn, POP); /* FIXME: lexbind */
+	case Bunwind_protect:	/* FIXME: avoid closure for lexbind */
+	  record_unwind_protect (Fprogn, POP);
 	  break;
 
-	case Bcondition_case:
+	case Bcondition_case:	/* FIXME: ill-suited for lexbind */
 	  {
 	    Lisp_Object handlers, body;
 	    handlers = POP;
 	    body = POP;
 	    BEFORE_POTENTIAL_GC ();
-	    TOP = internal_lisp_condition_case (TOP, body, handlers); /* FIXME: lexbind */
+	    TOP = internal_lisp_condition_case (TOP, body, handlers);
 	    AFTER_POTENTIAL_GC ();
 	    break;
 	  }
-- 
cgit v1.2.1


From 7914961cd705c8a88734ff87c581924bf48c3fe3 Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Wed, 16 Mar 2011 19:11:29 -0700
Subject: * bytecode.c (MAYBE_GC): Rewrite so as not to use empty "else".

---
 src/bytecode.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index bb4e87c019d..fca8a8e1ebe 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -363,6 +363,7 @@ unmark_byte_stack (void)
    We do this at every branch, to avoid loops that never GC.  */
 
 #define MAYBE_GC()					\
+ do {							\
   if (consing_since_gc > gc_cons_threshold		\
       && consing_since_gc > gc_relative_threshold)	\
     {							\
@@ -370,7 +371,7 @@ unmark_byte_stack (void)
       Fgarbage_collect ();				\
       AFTER_POTENTIAL_GC ();				\
     }							\
-  else
+ } while (0)
 
 /* Check for jumping out of range.  */
 
-- 
cgit v1.2.1


From 615f2d59a5ee849bc46c3fa57d41fd136f2d0962 Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Wed, 16 Mar 2011 19:18:00 -0700
Subject: * bytecode.c (CONSTANTLIM): Remove; unused.

(METER_CODE, Bscan_buffer, Bread_char, Bset_mark):
Define only if needed.
---
 src/bytecode.c | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index fca8a8e1ebe..ce2f06dfccb 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -76,11 +76,7 @@ Lisp_Object Qbyte_code_meter;
     }									\
 }
 
-#else /* no BYTE_CODE_METER */
-
-#define METER_CODE(last_code, this_code)
-
-#endif /* no BYTE_CODE_METER */
+#endif /* BYTE_CODE_METER */
 
 
 Lisp_Object Qbytecode;
@@ -146,7 +142,9 @@ Lisp_Object Qbytecode;
 #define Bpreceding_char 0150
 #define Bcurrent_column 0151
 #define Bindent_to 0152
+#ifdef BYTE_CODE_SAFE
 #define Bscan_buffer 0153 /* No longer generated as of v18 */
+#endif
 #define Beolp 0154
 #define Beobp 0155
 #define Bbolp 0156
@@ -154,8 +152,12 @@ Lisp_Object Qbytecode;
 #define Bcurrent_buffer 0160
 #define Bset_buffer 0161
 #define Bsave_current_buffer_1 0162 /* Replacing Bsave_current_buffer.  */
+#if 0
 #define Bread_char 0162 /* No longer generated as of v19 */
+#endif
+#ifdef BYTE_CODE_SAFE
 #define Bset_mark 0163 /* this loser is no longer generated as of v18 */
+#endif
 #define Binteractive_p 0164 /* Needed since interactive-p takes unevalled args */
 
 #define Bforward_char 0165
@@ -227,7 +229,6 @@ Lisp_Object Qbytecode;
 #define BinsertN 0261
 
 #define Bconstant 0300
-#define CONSTANTLIM 0100
 
 /* Whether to maintain a `top' and `bottom' field in the stack frame.  */
 #define BYTE_MAINTAIN_TOP (BYTE_CODE_SAFE || BYTE_MARK_STACK)
-- 
cgit v1.2.1


From 1c470562971bd86b1767ceb9ae95ece71228549f Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Wed, 30 Mar 2011 14:04:11 -0400
Subject: * src/bytecode.c (Fbyte_code): CAR and CDR can GC.

---
 src/bytecode.c | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index ce2f06dfccb..a7be8e26f27 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -554,7 +554,16 @@ If the third argument is incorrect, Emacs may crash.  */)
 	  {
 	    Lisp_Object v1;
 	    v1 = TOP;
-	    TOP = CAR (v1);
+	    if (CONSP (v1))
+	      TOP = XCAR (v1);
+	    else if (NILP (v1))
+	      TOP = Qnil;
+	    else
+	      {
+		BEFORE_POTENTIAL_GC ();
+		wrong_type_argument (Qlistp, v1);
+		AFTER_POTENTIAL_GC ();
+	      }
 	    break;
 	  }
 
@@ -580,7 +589,17 @@ If the third argument is incorrect, Emacs may crash.  */)
 	  {
 	    Lisp_Object v1;
 	    v1 = TOP;
-	    TOP = CDR (v1);
+	    if (CONSP (v1))
+	      TOP = XCDR (v1);
+	    else if (NILP (v1))
+	      TOP = Qnil;
+	    else
+	      {
+		BEFORE_POTENTIAL_GC ();
+		wrong_type_argument (Qlistp, v1);
+		AFTER_POTENTIAL_GC ();
+	      }
+	    break;
 	    break;
 	  }
 
@@ -911,13 +930,13 @@ If the third argument is incorrect, Emacs may crash.  */)
 	    v1 = POP;
 	    v2 = TOP;
 	    CHECK_NUMBER (v2);
-	    AFTER_POTENTIAL_GC ();
 	    op = XINT (v2);
 	    immediate_quit = 1;
 	    while (--op >= 0 && CONSP (v1))
 	      v1 = XCDR (v1);
 	    immediate_quit = 0;
 	    TOP = CAR (v1);
+	    AFTER_POTENTIAL_GC ();
 	    break;
 	  }
 
-- 
cgit v1.2.1


From 1be4d76143bb2d969e7c78f7af4c8d711e888205 Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Fri, 1 Apr 2011 00:18:17 -0700
Subject: * bytecode.c (Fbyte_code) [!defined BYTE_CODE_SAFE]: Remove var

that is set but not used.
---
 src/bytecode.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index a7be8e26f27..5a62c913a40 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -425,8 +425,8 @@ If the third argument is incorrect, Emacs may crash.  */)
 #ifdef BYTE_CODE_SAFE
   int const_length = XVECTOR (vector)->size;
   Lisp_Object *stacke;
-#endif
   int bytestr_length;
+#endif
   struct byte_stack stack;
   Lisp_Object *top;
   Lisp_Object result;
@@ -453,7 +453,9 @@ If the third argument is incorrect, Emacs may crash.  */)
        convert them back to the originally intended unibyte form.  */
     bytestr = Fstring_as_unibyte (bytestr);
 
+#ifdef BYTE_CODE_SAFE
   bytestr_length = SBYTES (bytestr);
+#endif
   vectorp = XVECTOR (vector)->contents;
 
   stack.byte_string = bytestr;
-- 
cgit v1.2.1


From 7200d79c65c65686495dd95e9f6dd436cf6db55e Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Fri, 1 Apr 2011 11:16:50 -0400
Subject: Miscellanous cleanups in preparation for the merge. *
 lisp/emacs-lisp/byte-opt.el (byte-optimize-form-code-walker): Remove debug
 statement. * lisp/emacs-lisp/bytecomp.el (byte-compile-single-version)
 (byte-compile-version-cond, byte-compile-delay-out)
 (byte-compile-delayed-out): Remove, unused. * src/bytecode.c (Fbyte_code):
 Revert to old calling convention. * src/lisp.h (COMPILED_PUSH_ARGS): Remove,
 unused.

---
 src/bytecode.c | 41 ++++++++++++++++-------------------------
 1 file changed, 16 insertions(+), 25 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 01ae8055ebf..5d94cb0fb39 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -51,7 +51,7 @@ by Hallvard:
  *
  * define BYTE_CODE_METER to enable generation of a byte-op usage histogram.
  */
-#define BYTE_CODE_SAFE 1
+/* #define BYTE_CODE_SAFE */
 /* #define BYTE_CODE_METER */
 
 
@@ -160,7 +160,7 @@ extern Lisp_Object Qand_optional, Qand_rest;
 #ifdef BYTE_CODE_SAFE
 #define Bset_mark 0163 /* this loser is no longer generated as of v18 */
 #endif
-#define Binteractive_p 0164 /* Obsolete.  */
+#define Binteractive_p 0164 /* Obsolete since Emacs-24.1.  */
 
 #define Bforward_char 0165
 #define Bforward_word 0166
@@ -185,16 +185,16 @@ extern Lisp_Object Qand_optional, Qand_rest;
 #define Bdup 0211
 
 #define Bsave_excursion 0212
-#define Bsave_window_excursion 0213 /* Obsolete.  */
+#define Bsave_window_excursion 0213 /* Obsolete since Emacs-24.1.  */
 #define Bsave_restriction 0214
 #define Bcatch 0215
 
 #define Bunwind_protect 0216
 #define Bcondition_case 0217
-#define Btemp_output_buffer_setup 0220 /* Obsolete.  */
-#define Btemp_output_buffer_show 0221  /* Obsolete.  */
+#define Btemp_output_buffer_setup 0220 /* Obsolete since Emacs-24.1.  */
+#define Btemp_output_buffer_show 0221  /* Obsolete since Emacs-24.1.  */
 
-#define Bunbind_all 0222	/* Obsolete.  */
+#define Bunbind_all 0222	/* Obsolete.  Never used.  */
 
 #define Bset_marker 0223
 #define Bmatch_beginning 0224
@@ -413,24 +413,15 @@ unmark_byte_stack (void)
   } while (0)
 
 
-DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, MANY, 0,
+DEFUN ("byte-code", Fbyte_code, Sbyte_code, 3, 3, 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.
-
-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) */)
-     (size_t nargs, Lisp_Object *args)
+If the third argument is incorrect, Emacs may crash.  */)
+  (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth)
 {
-  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);
+  return exec_byte_code (bytestr, vector, maxdepth, Qnil, 0, NULL);
 }
 
 /* Execute the byte-code in BYTESTR.  VECTOR is the constant vector, and
@@ -810,7 +801,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	  AFTER_POTENTIAL_GC ();
 	  break;
 
-	case Bunbind_all:	/* Obsolete.  */
+	case Bunbind_all:	/* Obsolete.  Never used.  */
 	  /* To unbind back to the beginning of this frame.  Not used yet,
 	     but will be needed for tail-recursion elimination.  */
 	  BEFORE_POTENTIAL_GC ();
@@ -938,12 +929,12 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 				 save_excursion_save ());
 	  break;
 
-	case Bsave_current_buffer: /* Obsolete.  */
+	case Bsave_current_buffer: /* Obsolete since ??.  */
 	case Bsave_current_buffer_1:
 	  record_unwind_protect (set_buffer_if_live, Fcurrent_buffer ());
 	  break;
 
-	case Bsave_window_excursion: /* Obsolete.  */
+	case Bsave_window_excursion: /* Obsolete since 24.1.  */
 	  {
 	    register int count = SPECPDL_INDEX ();
 	    record_unwind_protect (Fset_window_configuration,
@@ -985,7 +976,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	    break;
 	  }
 
-	case Btemp_output_buffer_setup: /* Obsolete.  */
+	case Btemp_output_buffer_setup: /* Obsolete since 24.1.  */
 	  BEFORE_POTENTIAL_GC ();
 	  CHECK_STRING (TOP);
 	  temp_output_buffer_setup (SSDATA (TOP));
@@ -993,7 +984,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	  TOP = Vstandard_output;
 	  break;
 
-	case Btemp_output_buffer_show: /* Obsolete.  */
+	case Btemp_output_buffer_show: /* Obsolete since 24.1.  */
 	  {
 	    Lisp_Object v1;
 	    BEFORE_POTENTIAL_GC ();
@@ -1465,7 +1456,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	  AFTER_POTENTIAL_GC ();
 	  break;
 
-	case Binteractive_p:	/* Obsolete.  */
+	case Binteractive_p:	/* Obsolete since 24.1.  */
 	  PUSH (Finteractive_p ());
 	  break;
 
-- 
cgit v1.2.1


From fdfc4bf34ecc9d0d7ee2241e246191a5f928a33a Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Mon, 4 Apr 2011 00:55:46 -0700
Subject: * bytecode.c (exec_byte_code): Rename local to avoid shadowing.

---
 src/bytecode.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 5879d312b07..b4a5354a0a4 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -938,12 +938,12 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 
 	case Bsave_window_excursion: /* Obsolete since 24.1.  */
 	  {
-	    register int count = SPECPDL_INDEX ();
+	    register int count1 = SPECPDL_INDEX ();
 	    record_unwind_protect (Fset_window_configuration,
 				   Fcurrent_window_configuration (Qnil));
 	    BEFORE_POTENTIAL_GC ();
 	    TOP = Fprogn (TOP);
-	    unbind_to (count, TOP);
+	    unbind_to (count1, TOP);
 	    AFTER_POTENTIAL_GC ();
 	    break;
 	  }
-- 
cgit v1.2.1


From 955cbe7b1720f09b2991b7d981147d9cc79d52e3 Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Sun, 10 Apr 2011 20:39:45 -0700
Subject: Declare Lisp_Object Q* variables to be 'static' if not exproted.

This makes it easier for human readers (and static analyzers)
to see whether these variables are used from other modules.
* alloc.c, buffer.c, bytecode.c, callint.c, casetab.c, category.c:
* ccl.c, character.c, charset.c, cmds.c, coding.c, composite.c:
* data.c, dbusbind.c, dired.c, editfns.c, eval.c, fileio.c, fns.c:
* font.c, frame.c, fringe.c, ftfont.c, image.c, keyboard.c, keymap.c:
* lread.c, macros.c, minibuf.c, print.c, process.c, search.c:
* sound.c, syntax.c, textprop.c, window.c, xdisp.c, xfaces.c, xfns.c:
* xmenu.c, xselect.c:
Declare Q* vars static if they are not used in other modules.
* ccl.h, character.h, charset.h, coding.h, composite.h, font.h:
* frame.h, intervals.h, keyboard.h, lisp.h, process.h, syntax.h:
Remove decls of unexported vars.
* keyboard.h (EVENT_HEAD_UNMODIFIED): Remove now-unused macro.
---
 src/bytecode.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index b4a5354a0a4..581e16678a6 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -80,7 +80,6 @@ Lisp_Object Qbyte_code_meter;
 
 
 Lisp_Object Qbytecode;
-extern Lisp_Object Qand_optional, Qand_rest;
 
 /*  Byte codes: */
 
-- 
cgit v1.2.1


From 0df1eac54fdf82a80a7611fe421d94a23ebd4a0a Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Sat, 23 Apr 2011 22:30:24 -0700
Subject: * bytecode.c (exec_byte_code): Don't use XVECTOR before CHECK_VECTOR.

---
 src/bytecode.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 581e16678a6..3bbd8831633 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -444,7 +444,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   /* Lisp_Object v1, v2; */
   Lisp_Object *vectorp;
 #ifdef BYTE_CODE_SAFE
-  int const_length = XVECTOR (vector)->size;
+  int const_length;
   Lisp_Object *stacke;
   int bytestr_length;
 #endif
@@ -466,6 +466,10 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   CHECK_VECTOR (vector);
   CHECK_NUMBER (maxdepth);
 
+#ifdef BYTE_CODE_SAFE
+  const_length = XVECTOR (vector)->size;
+#endif
+
   if (STRING_MULTIBYTE (bytestr))
     /* BYTESTR must have been produced by Emacs 20.2 or the earlier
        because they produced a raw 8-bit string for byte-code and now
-- 
cgit v1.2.1


From eab3844f965646b62e242aa622754b86d1fd3444 Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Mon, 25 Apr 2011 00:14:46 -0700
Subject: lisp.h: Fix a problem with aliasing and vector headers.

GCC 4.6.0 optimizes based on type-based alias analysis.  For
example, if b is of type struct buffer * and v of type struct
Lisp_Vector *, then gcc -O2 was incorrectly assuming that &b->size
!= &v->size, and therefore "v->size = 1; b->size = 2; return
v->size;" must therefore return 1.  This assumption is incorrect
for Emacs, since it type-puns struct Lisp_Vector * with many other
types.  To fix this problem, this patch adds a new type struct
vector_header that documents the constraints on layout of vectors
and pseudovectors, and helps optimizing compilers not get fooled
by Emacs's type punning.  It also adds the macros XSETTYPED_PVECTYPE
XSETTYPED_PSEUDOVECTOR, TYPED_PSEUDOVECTORP, for similar reasons.
* lisp.h (XVECTOR_SIZE): New convenience macro.  All previous uses of
XVECTOR (foo)->size replaced to use this macro, to avoid the hassle
of writing XVECTOR (foo)->header.size.
(XVECTOR_HEADER_SIZE): New macro, for use in XSETPSEUDOVECTOR.
(XSETTYPED_PVECTYPE): New macro, specifying the name of the size
member.
(XSETPVECTYPE): Rewrite in terms of new macro.
(XSETPVECTYPESIZE): New macro, specifying both type and size.
This is a bit clearer, and further avoids the possibility of
undesirable aliasing.
(XSETTYPED_PSEUDOVECTOR): New macro, specifying the size.
(XSETPSEUDOVECTOR): Rewrite in terms of XSETTYPED_PSEUDOVECTOR
and XVECTOR_HEADER_SIZE.
(XSETSUBR): Rewrite in terms of XSETTYPED_PSEUDOVECTOR and XSIZE,
since Lisp_Subr is a special case (no "next" field).
(ASIZE): Rewrite in terms of XVECTOR_SIZE.
(struct vector_header): New type.
(TYPED_PSEUDOVECTORP): New macro, also specifying the C type of the
object, to help avoid aliasing.
(PSEUDOVECTORP): Rewrite in terms of TYPED_PSEUDOVECTORP.
(SUBRP): Likewise, since Lisp_Subr is a special case.
* lisp.h (struct Lisp_Vector, struct Lisp_Char_Table):
(struct Lisp_Sub_Char_Table, struct Lisp_Bool_Vector):
(struct Lisp_Hash_Table): Combine first two members into a single
struct vector_header member.  All uses of "size" and "next" members
changed to be "header.size" and "header.next".
* buffer.h (struct buffer): Likewise.
* font.h (struct font_spec, struct font_entity, struct font): Likewise.
* frame.h (struct frame): Likewise.
* process.h (struct Lisp_Process): Likewise.
* termhooks.h (struct terminal): Likewise.
* window.c (struct save_window_data, struct saved_window): Likewise.
* window.h (struct window): Likewise.
* alloc.c (allocate_buffer, Fmake_bool_vector, allocate_pseudovector):
Use XSETPVECTYPESIZE, not XSETPVECTYPE, to avoid aliasing problems.
* buffer.c (init_buffer_once): Likewise.
* lread.c (defsubr): Use XSETTYPED_PVECTYPE, since Lisp_Subr is a
special case.
* process.c (Fformat_network_address): Use local var for size,
for brevity.
---
 src/bytecode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 3bbd8831633..839e0f7d54e 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -467,7 +467,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   CHECK_NUMBER (maxdepth);
 
 #ifdef BYTE_CODE_SAFE
-  const_length = XVECTOR (vector)->size;
+  const_length = XVECTOR_SIZE (vector);
 #endif
 
   if (STRING_MULTIBYTE (bytestr))
-- 
cgit v1.2.1


From 77b37c05572d1028d0ec2c264ac0ed3a89c0f4da Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Mon, 25 Apr 2011 14:34:39 -0700
Subject: * lisp.h: (XVECTOR_SIZE): Remove.  All uses replaced with ASIZE.
 (ASIZE): Now contains previous implementation of XVECTOR_SIZE instead of
 invoking XVECTOR_SIZE.

---
 src/bytecode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 839e0f7d54e..c3cd3d43072 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -467,7 +467,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   CHECK_NUMBER (maxdepth);
 
 #ifdef BYTE_CODE_SAFE
-  const_length = XVECTOR_SIZE (vector);
+  const_length = ASIZE (vector);
 #endif
 
   if (STRING_MULTIBYTE (bytestr))
-- 
cgit v1.2.1


From 2462470b9ec3876a54f1ce4c70561c478ceaf714 Mon Sep 17 00:00:00 2001
From: Stefan Monnier
Date: Wed, 1 Jun 2011 11:19:45 -0300
Subject: Miscellaneous tweaks. * lisp/emacs-lisp/cl-macs.el (dolist, dotimes):
 Use the same strategy for lexical scoping as in subr.el's dolist and dotimes.
 * lisp/emacs-lisp/bytecomp.el (byte-compile-unfold-bcf): Silence compiler
 warning. * lisp/thingatpt.el (forward-whitespace): Trivial coding style fix.
 * lisp/subr.el (with-output-to-temp-buffer): Provide an edebug spec. *
 lisp/international/ccl.el (ccl-compile): Trivial simplification. *
 lisp/help-fns.el (help-do-arg-highlight): Silence compiler warning. *
 lisp/emacs-lisp/testcover.el (testcover-end): Remove spurious `printflag'
 argument. * lisp/emacs-lisp/byte-run.el (make-obsolete,
 make-obsolete-variable): Purecopy the whole obsolescence data.

---
 src/bytecode.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index c3cd3d43072..74cf401bf1d 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -144,7 +144,7 @@ Lisp_Object Qbytecode;
 #define Bcurrent_column 0151
 #define Bindent_to 0152
 #ifdef BYTE_CODE_SAFE
-#define Bscan_buffer 0153 /* No longer generated as of v18 */
+#define Bscan_buffer 0153 /* No longer generated as of v18.  */
 #endif
 #define Beolp 0154
 #define Beobp 0155
@@ -956,7 +956,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 				 save_restriction_save ());
 	  break;
 
-	case Bcatch:		/* FIXME: ill-suited for lexbind */
+	case Bcatch:		/* FIXME: ill-suited for lexbind.  */
 	  {
 	    Lisp_Object v1;
 	    BEFORE_POTENTIAL_GC ();
@@ -966,11 +966,11 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	    break;
 	  }
 
-	case Bunwind_protect:	/* FIXME: avoid closure for lexbind */
+	case Bunwind_protect:	/* FIXME: avoid closure for lexbind.  */
 	  record_unwind_protect (Fprogn, POP);
 	  break;
 
-	case Bcondition_case:	/* FIXME: ill-suited for lexbind */
+	case Bcondition_case:	/* FIXME: ill-suited for lexbind.  */
 	  {
 	    Lisp_Object handlers, body;
 	    handlers = POP;
@@ -1779,8 +1779,8 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	    PUSH (*ptr);
 	    break;
 	  }
-	  /* stack-set-0 = discard; stack-set-1 = discard-1-preserve-tos.  */
 	case Bstack_set:
+	  /* stack-set-0 = discard; stack-set-1 = discard-1-preserve-tos.  */
 	  {
 	    Lisp_Object *ptr = top - (FETCH);
 	    *ptr = POP;
-- 
cgit v1.2.1


From f66c7cf8f794d6f7fd9ccb8794ffc519e4e89795 Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Tue, 14 Jun 2011 11:57:19 -0700
Subject: Variadic C functions now count arguments with ptrdiff_t.

This partly undoes my 2011-03-30 change, which replaced int with size_t.
Back then I didn't know that the Emacs coding style prefers signed int.
Also, in the meantime I found a few more instances where arguments
were being counted with int, which may truncate counts on 64-bit
machines, or EMACS_INT, which may be unnecessarily wide.
* lisp.h (struct Lisp_Subr.function.aMANY)
(DEFUN_ARGS_MANY, internal_condition_case_n, safe_call):
Arg counts are now ptrdiff_t, not size_t.
All variadic functions and their callers changed accordingly.
(struct gcpro.nvars): Now size_t, not size_t.  All uses changed.
* bytecode.c (exec_byte_code): Check maxdepth for overflow,
to avoid potential buffer overrun.  Don't assume arg counts fit in 'int'.
* callint.c (Fcall_interactively): Check arg count for overflow,
to avoid potential buffer overrun.  Use signed char, not 'int',
for 'varies' array, so that we needn't bother to check its size
calculation for overflow.
* editfns.c (Fformat): Use ptrdiff_t, not EMACS_INT, to count args.
* eval.c (apply_lambda):
* fns.c (Fmapconcat): Use XFASTINT, not XINT, to get args length.
(struct textprop_rec.argnum): Now ptrdiff_t, not int.  All uses changed.
(mapconcat): Use ptrdiff_t, not int and EMACS_INT, to count args.
---
 src/bytecode.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index 74cf401bf1d..adc9352fb6e 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -433,7 +433,7 @@ If the third argument is incorrect, Emacs may crash.  */)
 
 Lisp_Object
 exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
-		Lisp_Object args_template, int nargs, Lisp_Object *args)
+		Lisp_Object args_template, ptrdiff_t nargs, Lisp_Object *args)
 {
   int count = SPECPDL_INDEX ();
 #ifdef BYTE_CODE_METER
@@ -464,7 +464,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 
   CHECK_STRING (bytestr);
   CHECK_VECTOR (vector);
-  CHECK_NUMBER (maxdepth);
+  CHECK_NATNUM (maxdepth);
 
 #ifdef BYTE_CODE_SAFE
   const_length = ASIZE (vector);
@@ -486,6 +486,8 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   stack.byte_string = bytestr;
   stack.pc = stack.byte_string_start = SDATA (bytestr);
   stack.constants = vector;
+  if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object) < XFASTINT (maxdepth))
+    memory_full (SIZE_MAX);
   top = (Lisp_Object *) alloca (XFASTINT (maxdepth)
                                          * sizeof (Lisp_Object));
 #if BYTE_MAINTAIN_TOP
@@ -502,14 +504,14 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 
   if (INTEGERP (args_template))
     {
-      int at = XINT (args_template);
+      ptrdiff_t at = XINT (args_template);
       int rest = at & 128;
       int mandatory = at & 127;
-      int nonrest = at >> 8;
+      ptrdiff_t nonrest = at >> 8;
       eassert (mandatory <= nonrest);
       if (nargs <= nonrest)
 	{
-	  int i;
+	  ptrdiff_t i;
 	  for (i = 0 ; i < nargs; i++, args++)
 	    PUSH (*args);
 	  if (nargs < mandatory)
@@ -528,7 +530,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 	}
       else if (rest)
 	{
-	  int i;
+	  ptrdiff_t i;
 	  for (i = 0 ; i < nonrest; i++, args++)
 	    PUSH (*args);
 	  PUSH (Flist (nargs - nonrest, args));
-- 
cgit v1.2.1


From 80e88859ec7b69bb88e76e9d23c8dc16151bd836 Mon Sep 17 00:00:00 2001
From: Paul Eggert
Date: Tue, 14 Jun 2011 13:12:13 -0700
Subject: * bytecode.c (exec_byte_code): Use ptrdiff_t, not int, for vector
 length.

---
 src/bytecode.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/bytecode.c')

diff --git a/src/bytecode.c b/src/bytecode.c
index adc9352fb6e..58b26c79b84 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -444,7 +444,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
   /* Lisp_Object v1, v2; */
   Lisp_Object *vectorp;
 #ifdef BYTE_CODE_SAFE
-  int const_length;
+  ptrdiff_t const_length;
   Lisp_Object *stacke;
   int bytestr_length;
 #endif
-- 
cgit v1.2.1