Mercurial > hg > xemacs-beta
view lisp/update-elc.el @ 5127:a9c41067dd88 ben-lisp-object
more cleanups, terminology clarification, lots of doc work
-------------------- ChangeLog entries follow: --------------------
man/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* internals/internals.texi (Introduction to Allocation):
* internals/internals.texi (Integers and Characters):
* internals/internals.texi (Allocation from Frob Blocks):
* internals/internals.texi (lrecords):
* internals/internals.texi (Low-level allocation):
Rewrite section on allocation of Lisp objects to reflect the new
reality. Remove references to nonexistent XSETINT and XSETCHAR.
modules/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c (allocate_pgconn):
* postgresql/postgresql.c (allocate_pgresult):
* postgresql/postgresql.h (struct Lisp_PGconn):
* postgresql/postgresql.h (struct Lisp_PGresult):
* ldap/eldap.c (allocate_ldap):
* ldap/eldap.h (struct Lisp_LDAP):
Same changes as in src/ dir. See large log there in ChangeLog,
but basically:
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
../hlo/src/ChangeLog addition:
2010-03-05 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (old_alloc_sized_lcrecord):
* alloc.c (very_old_free_lcrecord):
* alloc.c (copy_lisp_object):
* alloc.c (zero_sized_lisp_object):
* alloc.c (zero_nonsized_lisp_object):
* alloc.c (lisp_object_storage_size):
* alloc.c (free_normal_lisp_object):
* alloc.c (FREE_FIXED_TYPE_WHEN_NOT_IN_GC):
* alloc.c (ALLOC_FROB_BLOCK_LISP_OBJECT):
* alloc.c (Fcons):
* alloc.c (noseeum_cons):
* alloc.c (make_float):
* alloc.c (make_bignum):
* alloc.c (make_bignum_bg):
* alloc.c (make_ratio):
* alloc.c (make_ratio_bg):
* alloc.c (make_ratio_rt):
* alloc.c (make_bigfloat):
* alloc.c (make_bigfloat_bf):
* alloc.c (size_vector):
* alloc.c (make_compiled_function):
* alloc.c (Fmake_symbol):
* alloc.c (allocate_extent):
* alloc.c (allocate_event):
* alloc.c (make_key_data):
* alloc.c (make_button_data):
* alloc.c (make_motion_data):
* alloc.c (make_process_data):
* alloc.c (make_timeout_data):
* alloc.c (make_magic_data):
* alloc.c (make_magic_eval_data):
* alloc.c (make_eval_data):
* alloc.c (make_misc_user_data):
* alloc.c (Fmake_marker):
* alloc.c (noseeum_make_marker):
* alloc.c (size_string_direct_data):
* alloc.c (make_uninit_string):
* alloc.c (make_string_nocopy):
* alloc.c (mark_lcrecord_list):
* alloc.c (alloc_managed_lcrecord):
* alloc.c (free_managed_lcrecord):
* alloc.c (sweep_lcrecords_1):
* alloc.c (malloced_storage_size):
* buffer.c (allocate_buffer):
* buffer.c (compute_buffer_usage):
* buffer.c (DEFVAR_BUFFER_LOCAL_1):
* buffer.c (nuke_all_buffer_slots):
* buffer.c (common_init_complex_vars_of_buffer):
* buffer.h (struct buffer_text):
* buffer.h (struct buffer):
* bytecode.c:
* bytecode.c (make_compiled_function_args):
* bytecode.c (size_compiled_function_args):
* bytecode.h (struct compiled_function_args):
* casetab.c (allocate_case_table):
* casetab.h (struct Lisp_Case_Table):
* charset.h (struct Lisp_Charset):
* chartab.c (fill_char_table):
* chartab.c (Fmake_char_table):
* chartab.c (make_char_table_entry):
* chartab.c (copy_char_table_entry):
* chartab.c (Fcopy_char_table):
* chartab.c (put_char_table):
* chartab.h (struct Lisp_Char_Table_Entry):
* chartab.h (struct Lisp_Char_Table):
* console-gtk-impl.h (struct gtk_device):
* console-gtk-impl.h (struct gtk_frame):
* console-impl.h (struct console):
* console-msw-impl.h (struct Lisp_Devmode):
* console-msw-impl.h (struct mswindows_device):
* console-msw-impl.h (struct msprinter_device):
* console-msw-impl.h (struct mswindows_frame):
* console-msw-impl.h (struct mswindows_dialog_id):
* console-stream-impl.h (struct stream_console):
* console-stream.c (stream_init_console):
* console-tty-impl.h (struct tty_console):
* console-tty-impl.h (struct tty_device):
* console-tty.c (allocate_tty_console_struct):
* console-x-impl.h (struct x_device):
* console-x-impl.h (struct x_frame):
* console.c (allocate_console):
* console.c (nuke_all_console_slots):
* console.c (DEFVAR_CONSOLE_LOCAL_1):
* console.c (common_init_complex_vars_of_console):
* data.c (make_weak_list):
* data.c (make_weak_box):
* data.c (make_ephemeron):
* database.c:
* database.c (struct Lisp_Database):
* database.c (allocate_database):
* database.c (finalize_database):
* device-gtk.c (allocate_gtk_device_struct):
* device-impl.h (struct device):
* device-msw.c:
* device-msw.c (mswindows_init_device):
* device-msw.c (msprinter_init_device):
* device-msw.c (finalize_devmode):
* device-msw.c (allocate_devmode):
* device-tty.c (allocate_tty_device_struct):
* device-x.c (allocate_x_device_struct):
* device.c:
* device.c (nuke_all_device_slots):
* device.c (allocate_device):
* dialog-msw.c (handle_question_dialog_box):
* elhash.c:
* elhash.c (struct Lisp_Hash_Table):
* elhash.c (finalize_hash_table):
* elhash.c (make_general_lisp_hash_table):
* elhash.c (Fcopy_hash_table):
* elhash.h (htentry):
* emacs.c (main_1):
* eval.c:
* eval.c (size_multiple_value):
* event-stream.c (finalize_command_builder):
* event-stream.c (allocate_command_builder):
* event-stream.c (free_command_builder):
* event-stream.c (event_stream_generate_wakeup):
* event-stream.c (event_stream_resignal_wakeup):
* event-stream.c (event_stream_disable_wakeup):
* event-stream.c (event_stream_wakeup_pending_p):
* events.h (struct Lisp_Timeout):
* events.h (struct command_builder):
* extents-impl.h:
* extents-impl.h (struct extent_auxiliary):
* extents-impl.h (struct extent_info):
* extents-impl.h (set_extent_no_chase_aux_field):
* extents-impl.h (set_extent_no_chase_normal_field):
* extents.c:
* extents.c (gap_array_marker):
* extents.c (gap_array):
* extents.c (extent_list_marker):
* extents.c (extent_list):
* extents.c (stack_of_extents):
* extents.c (gap_array_make_marker):
* extents.c (extent_list_make_marker):
* extents.c (allocate_extent_list):
* extents.c (SLOT):
* extents.c (mark_extent_auxiliary):
* extents.c (allocate_extent_auxiliary):
* extents.c (attach_extent_auxiliary):
* extents.c (size_gap_array):
* extents.c (finalize_extent_info):
* extents.c (allocate_extent_info):
* extents.c (uninit_buffer_extents):
* extents.c (allocate_soe):
* extents.c (copy_extent):
* extents.c (vars_of_extents):
* extents.h:
* faces.c (allocate_face):
* faces.h (struct Lisp_Face):
* faces.h (struct face_cachel):
* file-coding.c:
* file-coding.c (finalize_coding_system):
* file-coding.c (sizeof_coding_system):
* file-coding.c (Fcopy_coding_system):
* file-coding.h (struct Lisp_Coding_System):
* file-coding.h (MARKED_SLOT):
* fns.c (size_bit_vector):
* font-mgr.c:
* font-mgr.c (finalize_fc_pattern):
* font-mgr.c (print_fc_pattern):
* font-mgr.c (Ffc_pattern_p):
* font-mgr.c (Ffc_pattern_create):
* font-mgr.c (Ffc_name_parse):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* font-mgr.c (Ffc_pattern_add):
* font-mgr.c (Ffc_pattern_del):
* font-mgr.c (Ffc_pattern_get):
* font-mgr.c (fc_config_create_using):
* font-mgr.c (fc_strlist_to_lisp_using):
* font-mgr.c (fontset_to_list):
* font-mgr.c (Ffc_config_p):
* font-mgr.c (Ffc_config_up_to_date):
* font-mgr.c (Ffc_config_build_fonts):
* font-mgr.c (Ffc_config_get_cache):
* font-mgr.c (Ffc_config_get_fonts):
* font-mgr.c (Ffc_config_set_current):
* font-mgr.c (Ffc_config_get_blanks):
* font-mgr.c (Ffc_config_get_rescan_interval):
* font-mgr.c (Ffc_config_set_rescan_interval):
* font-mgr.c (Ffc_config_app_font_add_file):
* font-mgr.c (Ffc_config_app_font_add_dir):
* font-mgr.c (Ffc_config_app_font_clear):
* font-mgr.c (size):
* font-mgr.c (Ffc_config_substitute):
* font-mgr.c (Ffc_font_render_prepare):
* font-mgr.c (Ffc_font_match):
* font-mgr.c (Ffc_font_sort):
* font-mgr.c (finalize_fc_config):
* font-mgr.c (print_fc_config):
* font-mgr.h:
* font-mgr.h (struct fc_pattern):
* font-mgr.h (XFC_PATTERN):
* font-mgr.h (struct fc_config):
* font-mgr.h (XFC_CONFIG):
* frame-gtk.c (allocate_gtk_frame_struct):
* frame-impl.h (struct frame):
* frame-msw.c (mswindows_init_frame_1):
* frame-x.c (allocate_x_frame_struct):
* frame.c (nuke_all_frame_slots):
* frame.c (allocate_frame_core):
* gc.c:
* gc.c (GC_CHECK_NOT_FREE):
* glyphs.c (finalize_image_instance):
* glyphs.c (allocate_image_instance):
* glyphs.c (Fcolorize_image_instance):
* glyphs.c (allocate_glyph):
* glyphs.c (unmap_subwindow_instance_cache_mapper):
* glyphs.c (register_ignored_expose):
* glyphs.h (struct Lisp_Image_Instance):
* glyphs.h (struct Lisp_Glyph):
* glyphs.h (struct glyph_cachel):
* glyphs.h (struct expose_ignore):
* gui.c (allocate_gui_item):
* gui.h (struct Lisp_Gui_Item):
* keymap.c (struct Lisp_Keymap):
* keymap.c (make_keymap):
* lisp.h:
* lisp.h (struct Lisp_String_Direct_Data):
* lisp.h (struct Lisp_String_Indirect_Data):
* lisp.h (struct Lisp_Vector):
* lisp.h (struct Lisp_Bit_Vector):
* lisp.h (DECLARE_INLINE_LISP_BIT_VECTOR):
* lisp.h (struct weak_box):
* lisp.h (struct ephemeron):
* lisp.h (struct weak_list):
* lrecord.h:
* lrecord.h (struct lrecord_implementation):
* lrecord.h (MC_ALLOC_CALL_FINALIZER):
* lrecord.h (struct lcrecord_list):
* lstream.c (finalize_lstream):
* lstream.c (sizeof_lstream):
* lstream.c (Lstream_new):
* lstream.c (Lstream_delete):
* lstream.h (struct lstream):
* marker.c:
* marker.c (finalize_marker):
* marker.c (compute_buffer_marker_usage):
* mule-charset.c:
* mule-charset.c (make_charset):
* mule-charset.c (compute_charset_usage):
* objects-impl.h (struct Lisp_Color_Instance):
* objects-impl.h (struct Lisp_Font_Instance):
* objects-tty-impl.h (struct tty_color_instance_data):
* objects-tty-impl.h (struct tty_font_instance_data):
* objects-tty.c (tty_initialize_color_instance):
* objects-tty.c (tty_initialize_font_instance):
* objects.c (finalize_color_instance):
* objects.c (Fmake_color_instance):
* objects.c (finalize_font_instance):
* objects.c (Fmake_font_instance):
* objects.c (reinit_vars_of_objects):
* opaque.c:
* opaque.c (sizeof_opaque):
* opaque.c (make_opaque_ptr):
* opaque.c (free_opaque_ptr):
* opaque.h:
* opaque.h (Lisp_Opaque):
* opaque.h (Lisp_Opaque_Ptr):
* print.c (printing_unreadable_lcrecord):
* print.c (external_object_printer):
* print.c (debug_p4):
* process.c (finalize_process):
* process.c (make_process_internal):
* procimpl.h (struct Lisp_Process):
* rangetab.c (Fmake_range_table):
* rangetab.c (Fcopy_range_table):
* rangetab.h (struct Lisp_Range_Table):
* scrollbar.c:
* scrollbar.c (create_scrollbar_instance):
* scrollbar.c (compute_scrollbar_instance_usage):
* scrollbar.h (struct scrollbar_instance):
* specifier.c (finalize_specifier):
* specifier.c (sizeof_specifier):
* specifier.c (set_specifier_caching):
* specifier.h (struct Lisp_Specifier):
* specifier.h (struct specifier_caching):
* symeval.h:
* symeval.h (SYMBOL_VALUE_MAGIC_P):
* symeval.h (DEFVAR_SYMVAL_FWD):
* symsinit.h:
* syntax.c (init_buffer_syntax_cache):
* syntax.h (struct syntax_cache):
* toolbar.c:
* toolbar.c (allocate_toolbar_button):
* toolbar.c (update_toolbar_button):
* toolbar.h (struct toolbar_button):
* tooltalk.c (struct Lisp_Tooltalk_Message):
* tooltalk.c (make_tooltalk_message):
* tooltalk.c (struct Lisp_Tooltalk_Pattern):
* tooltalk.c (make_tooltalk_pattern):
* ui-gtk.c:
* ui-gtk.c (allocate_ffi_data):
* ui-gtk.c (emacs_gtk_object_finalizer):
* ui-gtk.c (allocate_emacs_gtk_object_data):
* ui-gtk.c (allocate_emacs_gtk_boxed_data):
* ui-gtk.h:
* window-impl.h (struct window):
* window-impl.h (struct window_mirror):
* window.c (finalize_window):
* window.c (allocate_window):
* window.c (new_window_mirror):
* window.c (mark_window_as_deleted):
* window.c (make_dummy_parent):
* window.c (compute_window_mirror_usage):
* window.c (compute_window_usage):
Overall point of this change and previous ones in this repository:
(1) Introduce new, clearer terminology: everything other than int
or char is a "record" object, which comes in two types: "normal
objects" and "frob-block objects". Fix up all places that
referred to frob-block objects as "simple", "basic", etc.
(2) Provide an advertised interface for doing operations on Lisp
objects, including creating new types, that is clean and
consistent in its naming, uses the above-referenced terms and
avoids referencing "lrecords", "old lcrecords", etc., which should
hide under the surface.
(3) Make the size_in_bytes and finalizer methods take a
Lisp_Object rather than a void * for consistency with other methods.
(4) Separate finalizer method into finalizer and disksaver, so
that normal finalize methods don't have to worry about disksaving.
Other specifics:
(1) Renaming:
LISP_OBJECT_HEADER -> NORMAL_LISP_OBJECT_HEADER
ALLOC_LISP_OBJECT -> ALLOC_NORMAL_LISP_OBJECT
implementation->basic_p -> implementation->frob_block_p
ALLOCATE_FIXED_TYPE_AND_SET_IMPL -> ALLOC_FROB_BLOCK_LISP_OBJECT
*FCCONFIG*, wrap_fcconfig -> *FC_CONFIG*, wrap_fc_config
*FCPATTERN*, wrap_fcpattern -> *FC_PATTERN*, wrap_fc_pattern
(the last two changes make the naming of these macros consistent
with the naming of all other macros, since the objects are named
fc-config and fc-pattern with a hyphen)
(2) Lots of documentation fixes in lrecord.h.
(3) Eliminate macros for copying, freeing, zeroing objects, getting
their storage size. Instead, new functions:
zero_sized_lisp_object()
zero_nonsized_lisp_object()
lisp_object_storage_size()
free_normal_lisp_object()
(copy_lisp_object() already exists)
LISP_OBJECT_FROB_BLOCK_P() (actually a macro)
Eliminated:
free_lrecord()
zero_lrecord()
copy_lrecord()
copy_sized_lrecord()
old_copy_lcrecord()
old_copy_sized_lcrecord()
old_zero_lcrecord()
old_zero_sized_lcrecord()
LISP_OBJECT_STORAGE_SIZE()
COPY_SIZED_LISP_OBJECT()
COPY_SIZED_LCRECORD()
COPY_LISP_OBJECT()
ZERO_LISP_OBJECT()
FREE_LISP_OBJECT()
(4) Catch the remaining places where lrecord stuff was used directly
and use the advertised interface, e.g. alloc_sized_lrecord() ->
ALLOC_SIZED_LISP_OBJECT().
(5) Make certain statically-declared pseudo-objects
(buffer_local_flags, console_local_flags) have their lheader
initialized correctly, so things like copy_lisp_object() can work
on them. Make extent_auxiliary_defaults a proper heap object
Vextent_auxiliary_defaults, and make extent auxiliaries dumpable
so that this object can be dumped. allocate_extent_auxiliary()
now just creates the object, and attach_extent_auxiliary()
creates an extent auxiliary and attaches to an extent, like the
old allocate_extent_auxiliary().
(6) Create EXTENT_AUXILIARY_SLOTS macro, similar to the foo-slots.h
files but in a macro instead of a file. The purpose is to avoid
duplication when iterating over all the slots in an extent auxiliary.
Use it.
(7) In lstream.c, don't zero out object after allocation because
allocation routines take care of this.
(8) In marker.c, fix a mistake in computing marker overhead.
(9) In print.c, clean up printing_unreadable_lcrecord(),
external_object_printer() to avoid lots of ifdef NEW_GC's.
(10) Separate toolbar-button allocation into a separate
allocate_toolbar_button() function for use in the example code
in lrecord.h.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Fri, 05 Mar 2010 04:08:17 -0600 |
| parents | 8431b52e43b1 |
| children | 99f8ebc082d9 |
line wrap: on
line source
;;; update-elc.el --- Bytecompile out-of-date dumped files, pre-dumping ;; Copyright (C) 1997 Free Software Foundation, Inc. ;; Copyright (C) 1996 Sun Microsystems, Inc. ;; Copyright (C) 2001, 2003 Ben Wing. ;; Author: Ben Wing <ben@xemacs.org> ;; Based On: Original by Steven L Baur <steve@xemacs.org> ;; Maintainer: XEmacs Development Team ;; Keywords: internal ;; This file is part of XEmacs. ;; XEmacs is free software; you can redistribute it and/or modify it ;; under the terms of the GNU General Public License as published by ;; the Free Software Foundation; either version 2, or (at your option) ;; any later version. ;; XEmacs is distributed in the hope that it will be useful, but ;; WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ;; General Public License for more details. ;; You should have received a copy of the GNU General Public License ;; along with XEmacs; see the file COPYING. If not, write to the ;; Free Software Foundation, 59 Temple Place - Suite 330, ;; Boston, MA 02111-1307, USA. ;;; Synched up with: Not in FSF. ;;; Commentary: ;; Byte compile the .EL files necessary to dump out xemacs. ;; Also update the auto-autoloads.el files. ;; Use this file like this: ;; temacs -batch -l ../lisp/update-elc.el $lisp ;; where $lisp comes from the Makefile. .elc files listed in $lisp will ;; cause the corresponding .el file to be compiled. .el files listed in ;; $lisp will be ignored. ;; (the idea here is that you can bootstrap if your .ELC files ;; are missing or badly out-of-date) ;; See also update-elc-2.el ;;; Code: ;; Help debug problems. (setq stack-trace-on-error t load-always-display-messages t) (defvar processed nil) (defvar update-elc-files-to-compile nil) (defvar need-to-rebuild-autoloads nil) (defvar need-to-rebuild-mule-autoloads nil) (defvar need-to-recompile-autoloads nil) (defvar need-to-recompile-mule-autoloads nil) (defvar exe-target nil) (defvar dump-target nil) (defvar dump-target-out-of-date-wrt-dump-files nil) ;(defvar dump-target-out-of-date-wrt-exe-target nil) ;(setq update-elc-files-to-compile ; (delq nil ; (mapcar (function ; (lambda (x) ; (if (string-match "\.elc$" x) ; (let ((src (substring x 0 -1))) ; (if (file-newer-than-file-p src x) ; (progn ; (and (file-exists-p x) ; (null (file-writable-p x)) ; (set-file-modes x (logior (file-modes x) 128))) ; src)))))) ; ;; -batch gets filtered out. ; (nthcdr 3 command-line-args)))) (defvar build-directory (expand-file-name ".." invocation-directory)) (defvar source-lisp (file-name-directory (expand-file-name (nth 2 command-line-args)))) (defvar source-lisp-mule (expand-file-name "mule" source-lisp)) (defvar source-directory (expand-file-name ".." source-lisp)) (defvar aa-lisp (expand-file-name "auto-autoloads.el" source-lisp)) (defvar aac-lisp (expand-file-name "auto-autoloads.elc" source-lisp)) (defvar aa-lisp-mule (expand-file-name "auto-autoloads.el" source-lisp-mule)) (defvar aac-lisp-mule (expand-file-name "auto-autoloads.elc" source-lisp-mule)) (setq load-path (list source-lisp)) (load "find-paths.el") (load "packages.el") (load "setup-paths.el") ;; Lisp files loaded in order to byte compile anything. If any are out of ;; date, we need to load them as .el's, byte compile them, and reload as ;; .elc's. (defvar lisp-files-needed-for-byte-compilation '("bytecomp" "byte-optimize")) ;; Lisp files not in `lisp-files-needed-for-byte-compilation' that need ;; early byte compilation. These are files loaded by update-elc.el in ;; order to do the compilation of all the rest of the files. (defvar lisp-files-needing-early-byte-compilation '("easy-mmode" "autoload" "shadow" "cl-macs")) (defvar unbytecompiled-lisp-files '("paths.el" "dumped-lisp.el" "dumped-pkg-lisp.el" "raw-process.el") "Lisp files that should not be byte compiled. Files in `additional-dump-dependencies' do not need to be listed here.") (defvar additional-dump-dependencies (nconc '("loadup.el" "loadup-el.el" "update-elc.el") (if (featurep 'mule) '("mule/make-coding-system"))) "Lisp files that are not dumped but which the dump depends on. If any of these files are changed, we need to redump.") (defvar lisp-files-ignored-when-checking-for-autoload-updating '("custom-load.el" "auto-autoloads.el") "Lisp files that should not trigger auto-autoloads rebuilding.") (defun update-elc-chop-extension (file) (if (string-match "\\.elc?$" file) (substring file 0 (match-beginning 0)) file)) ;; we used to call packages-list-autoloads here, but it's false generality. ;; we need to handle each autoload file differently and there are only ;; two of them. (let (preloaded-file-list site-load-packages files-to-process) (load (expand-file-name "dumped-lisp.el" source-lisp)) ;; two setups here: ;; (1) temacs.exe is undumped, dumped into xemacs.exe. Happens with ;; unexec, but also with pdump under MS Windows native, since ;; the dumped data is stored as a resource in the xemacs.exe ;; executable. ;; (2) xemacs.exe is dumped or undumped. Running `xemacs -nd' gets ;; you the equivalent of `temacs'. Dumping creates a file ;; `xemacs.dmp'. (cond ((eq system-type 'windows-nt) (setq exe-target "src/temacs.exe" dump-target "src/xemacs.exe")) ;; #### need better ways of getting config params ((not (memq 'pdump (emacs-run-status))) (setq exe-target "src/temacs" dump-target "src/xemacs")) (t (setq exe-target "src/xemacs" dump-target "src/xemacs.dmp"))) (setq exe-target (expand-file-name exe-target build-directory)) (setq dump-target (expand-file-name dump-target build-directory)) ;; Not currently used. ; (setq dump-target-out-of-date-wrt-exe-target ; (cond ((not dump-target) t) ; (temacs-exe (file-newer-than-file-p temacs-exe dump-target)) ; ((not data-file) t) ; (t (file-newer-than-file-p dump-target data-file)))) ; (setq dump-target-exists (or (and temacs-exe dump-target) ; (and data-file dump-target)))) ;; Path setup (let ((package-preloaded-file-list (packages-collect-package-dumped-lisps late-package-load-path))) (setq preloaded-file-list (append package-preloaded-file-list preloaded-file-list packages-hardcoded-lisp))) (load (expand-file-name "site-packages" source-directory) t t) (setq preloaded-file-list (append packages-hardcoded-lisp preloaded-file-list site-load-packages)) ;; bytecomp, byte-optimize, autoload, etc. are mentioned specially ;; in the lisp-files-need* variables. (setq files-to-process (append lisp-files-needed-for-byte-compilation lisp-files-needing-early-byte-compilation additional-dump-dependencies preloaded-file-list)) (while files-to-process (let* ((arg (car files-to-process)) (arg-is-dump-dependency (or (member arg preloaded-file-list) (member arg additional-dump-dependencies))) (arg-sans-extension (update-elc-chop-extension arg)) (full-arg (locate-library arg-sans-extension)) (full-arg-sans-extension (if (null full-arg) (progn (print (format "Error: Library file %s not found" arg)) (backtrace) ;; Uncomment in case of trouble ;;(print (format "late-package-hierarchies: %S" late-package-hierarchies)) ;;(print (format "guessed-roots: %S" ;; (paths-find-emacs-roots ;; invocation-directory invocation-name))) (kill-emacs)) (update-elc-chop-extension full-arg))) (full-arg-el (concat full-arg-sans-extension ".el")) (full-arg-elc (concat full-arg-sans-extension ".elc")) (full-arg-dir (file-name-directory full-arg-el))) ; (print full-arg-el) ;; now check if .el or .elc is newer than the dumped exe. ;; if so, need to redump. (when (and dump-target arg-is-dump-dependency ;; no need to check for existence of either of the files ;; because of the definition of file-newer-than-file-p. (or (file-newer-than-file-p full-arg-el dump-target) (file-newer-than-file-p full-arg-elc dump-target))) (setq dump-target-out-of-date-wrt-dump-files t)) (if (and (not (member (file-name-nondirectory arg) unbytecompiled-lisp-files)) (not (member (file-name-nondirectory arg) additional-dump-dependencies)) (not (member full-arg-el processed)) ;; no need to check for existence of either of the files ;; because of the definition of file-newer-than-file-p. (file-newer-than-file-p full-arg-el full-arg-elc)) (setq processed (cons full-arg-el processed))) (setq files-to-process (cdr files-to-process)))) ;; Check if we need to rebuild the auto-autoloads.el files -- that is, ;; if ANY .el files have changed. (let ((dirs-to-check (list source-lisp source-lisp-mule))) (while dirs-to-check (let* ((dir (car dirs-to-check)) (full-dir (expand-file-name dir)) (all-files-in-dir (directory-files full-dir t "\\.el$" nil t)) (autoload-file (expand-file-name "auto-autoloads.el" full-dir)) (autoload-is-mule (equal dir source-lisp-mule))) (while all-files-in-dir (let* ((full-arg (car all-files-in-dir))) ;; custom-load.el always gets regenerated so don't let that ;; trigger us. (when (and (not (member (file-name-nondirectory full-arg) lisp-files-ignored-when-checking-for-autoload-updating )) (file-newer-than-file-p full-arg autoload-file)) (if autoload-is-mule (setq need-to-rebuild-mule-autoloads t) (setq need-to-rebuild-autoloads t)))) (setq all-files-in-dir (cdr all-files-in-dir)))) (setq dirs-to-check (cdr dirs-to-check)))) (if dump-target-out-of-date-wrt-dump-files (condition-case nil (write-region-internal "foo" nil (expand-file-name "src/NEEDTODUMP" build-directory)) (file-error nil))) ) (when (or need-to-rebuild-autoloads ;; no real need for the following check either, because if the file ;; doesn't exist, need-to-rebuild-autoloads gets set above. but ;; it's only one call, so it won't slow things down much and it keeps ;; the logic cleaner. (not (file-exists-p aa-lisp)) ;; no need to check for file-exists of .elc due to definition ;; of file-newer-than-file-p (file-newer-than-file-p aa-lisp aac-lisp)) (setq need-to-recompile-autoloads t)) (when (or need-to-rebuild-mule-autoloads ;; not necessary but ... see comment above. (not (file-exists-p aa-lisp-mule)) ;; no need to check for file-exists of .elc due to definition ;; of file-newer-than-file-p (file-newer-than-file-p aa-lisp-mule aac-lisp-mule)) (setq need-to-recompile-mule-autoloads t)) (when (not (featurep 'mule)) ;; sorry charlie. (setq need-to-rebuild-mule-autoloads nil need-to-recompile-mule-autoloads nil)) (setq update-elc-files-to-compile (append update-elc-files-to-compile (nreverse processed))) ;(print update-elc-files-to-compile) (let ((do-autoload-commands (append (if (or need-to-rebuild-autoloads need-to-rebuild-mule-autoloads) (list "-l" "autoload")) (if need-to-rebuild-autoloads (list "-f" "batch-update-directory-autoloads" "auto" source-lisp)) (if need-to-rebuild-mule-autoloads (list "-f" "batch-update-directory-autoloads" "mule" source-lisp-mule)) (if need-to-recompile-autoloads (list "-f" "batch-byte-compile-one-file" aa-lisp)) (if need-to-recompile-mule-autoloads (list "-f" "batch-byte-compile-one-file" aa-lisp-mule))))) (condition-case nil (delete-file (expand-file-name "src/REBUILD_AUTOLOADS" build-directory)) (file-error nil)) (cond ((and (not update-elc-files-to-compile) (not need-to-rebuild-autoloads) (not need-to-rebuild-mule-autoloads) (not need-to-recompile-autoloads) (not need-to-recompile-mule-autoloads)) ;; (1) Nothing to do at all. ) ((not update-elc-files-to-compile) ;; (2) We have no files to byte-compile, but we do need to ;; regenerate and compile the auto-autoloads file, so signal ;; update-elc-2 to do it. This is much faster than loading ;; all the .el's and doing it here. (We only need to rebuild ;; the autoloads here when we have files to compile, since ;; they may depend on the updated autoloads.) (condition-case nil (write-region-internal "foo" nil (expand-file-name "src/REBUILD_AUTOLOADS" build-directory)) (file-error nil)) ) (t (let ((bc-bootstrap (mapcar #'(lambda (arg) (concat (update-elc-chop-extension (locate-library arg)) ".el")) lisp-files-needed-for-byte-compilation)) (bootstrap-other (mapcar #'(lambda (arg) (concat (update-elc-chop-extension (locate-library arg)) ".el")) lisp-files-needing-early-byte-compilation))) (setq inhibit-autoloads t) ;; if bytecomp or byte-optimize need recompiling, then load ;; the .el version of them first, recompile them, and reload ;; the .elc versions to recompile everything else (so we won't ;; be waiting until the cows come home). we need to set ;; load-ignore-elc-files because byte-optimize gets autoloaded ;; from bytecomp. (let ((recompile-bc-bootstrap (apply #'nconc (mapcar #'(lambda (arg) (when (member arg update-elc-files-to-compile) (append '("-f" "batch-byte-compile-one-file") (list arg)))) bc-bootstrap))) (recompile-bootstrap-other (apply #'nconc (mapcar #'(lambda (arg) (when (member arg update-elc-files-to-compile) (append '("-f" "batch-byte-compile-one-file") (list arg)))) bootstrap-other)))) (mapc #'(lambda (arg) (setq update-elc-files-to-compile (delete arg update-elc-files-to-compile))) (append bc-bootstrap bootstrap-other)) (setq command-line-args (append '("-l" "loadup-el.el" "run-temacs" "-batch" "-no-packages" "-no-autoloads" "-eval" "(setq stack-trace-on-error t)" "-eval" "(setq load-always-display-messages t)") (when recompile-bc-bootstrap (append '("-eval" "(setq load-ignore-elc-files t)" "-l" "bytecomp") recompile-bc-bootstrap '("-eval" "(setq load-ignore-elc-files nil)"))) '("-l" "bytecomp") ;; likewise, recompile autoload.el etc. if out-of-date. recompile-bootstrap-other ;; then generate autoloads for lisp and maybe lisp/mule. do-autoload-commands ;; now load the autoloads and compile alles anderes. '("-eval" "(setq inhibit-autoloads nil)" "-f" "startup-load-autoloads" "-f" "batch-byte-compile") update-elc-files-to-compile )))) ;;(print command-line-args) (load "loadup-el.el")))) (kill-emacs) ;;; update-elc.el ends here