Mercurial > hg > xemacs-beta
annotate src/dynarr.c @ 4952:19a72041c5ed
Mule-izing, various fixes related to char * arguments
-------------------- ChangeLog entries follow: --------------------
modules/ChangeLog addition:
2010-01-26 Ben Wing <ben@xemacs.org>
* postgresql/postgresql.c:
* postgresql/postgresql.c (CHECK_LIVE_CONNECTION):
* postgresql/postgresql.c (print_pgresult):
* postgresql/postgresql.c (Fpq_conn_defaults):
* postgresql/postgresql.c (Fpq_connectdb):
* postgresql/postgresql.c (Fpq_connect_start):
* postgresql/postgresql.c (Fpq_result_status):
* postgresql/postgresql.c (Fpq_res_status):
Mule-ize large parts of it.
2010-01-26 Ben Wing <ben@xemacs.org>
* ldap/eldap.c (print_ldap):
* ldap/eldap.c (allocate_ldap):
Use write_ascstring().
src/ChangeLog addition:
2010-01-26 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (build_ascstring):
* alloc.c (build_msg_cistring):
* alloc.c (staticpro_1):
* alloc.c (staticpro_name):
* alloc.c (staticpro_nodump_1):
* alloc.c (staticpro_nodump_name):
* alloc.c (unstaticpro_nodump_1):
* alloc.c (mcpro_1):
* alloc.c (mcpro_name):
* alloc.c (object_memory_usage_stats):
* alloc.c (common_init_alloc_early):
* alloc.c (init_alloc_once_early):
* buffer.c (print_buffer):
* buffer.c (vars_of_buffer):
* buffer.c (common_init_complex_vars_of_buffer):
* buffer.c (init_initial_directory):
* bytecode.c (invalid_byte_code):
* bytecode.c (print_compiled_function):
* bytecode.c (mark_compiled_function):
* chartab.c (print_table_entry):
* chartab.c (print_char_table):
* config.h.in:
* console-gtk.c:
* console-gtk.c (gtk_device_to_console_connection):
* console-gtk.c (gtk_semi_canonicalize_console_connection):
* console-gtk.c (gtk_canonicalize_console_connection):
* console-gtk.c (gtk_semi_canonicalize_device_connection):
* console-gtk.c (gtk_canonicalize_device_connection):
* console-stream.c (stream_init_frame_1):
* console-stream.c (vars_of_console_stream):
* console-stream.c (init_console_stream):
* console-x.c (x_semi_canonicalize_console_connection):
* console-x.c (x_semi_canonicalize_device_connection):
* console-x.c (x_canonicalize_device_connection):
* console-x.h:
* data.c (eq_with_ebola_notice):
* data.c (Fsubr_interactive):
* data.c (Fnumber_to_string):
* data.c (digit_to_number):
* device-gtk.c (gtk_init_device):
* device-msw.c (print_devmode):
* device-x.c (x_event_name):
* dialog-msw.c (handle_directory_dialog_box):
* dialog-msw.c (handle_file_dialog_box):
* dialog-msw.c (vars_of_dialog_mswindows):
* doc.c (weird_doc):
* doc.c (Fsnarf_documentation):
* doc.c (vars_of_doc):
* dumper.c (pdump):
* dynarr.c:
* dynarr.c (Dynarr_realloc):
* editfns.c (Fuser_real_login_name):
* editfns.c (get_home_directory):
* elhash.c (print_hash_table_data):
* elhash.c (print_hash_table):
* emacs.c (main_1):
* emacs.c (vars_of_emacs):
* emodules.c:
* emodules.c (_emodules_list):
* emodules.c (Fload_module):
* emodules.c (Funload_module):
* emodules.c (Flist_modules):
* emodules.c (find_make_module):
* emodules.c (attempt_module_delete):
* emodules.c (emodules_load):
* emodules.c (emodules_doc_subr):
* emodules.c (emodules_doc_sym):
* emodules.c (syms_of_module):
* emodules.c (vars_of_module):
* emodules.h:
* eval.c (print_subr):
* eval.c (signal_call_debugger):
* eval.c (build_error_data):
* eval.c (signal_error):
* eval.c (maybe_signal_error):
* eval.c (signal_continuable_error):
* eval.c (maybe_signal_continuable_error):
* eval.c (signal_error_2):
* eval.c (maybe_signal_error_2):
* eval.c (signal_continuable_error_2):
* eval.c (maybe_signal_continuable_error_2):
* eval.c (signal_ferror):
* eval.c (maybe_signal_ferror):
* eval.c (signal_continuable_ferror):
* eval.c (maybe_signal_continuable_ferror):
* eval.c (signal_ferror_with_frob):
* eval.c (maybe_signal_ferror_with_frob):
* eval.c (signal_continuable_ferror_with_frob):
* eval.c (maybe_signal_continuable_ferror_with_frob):
* eval.c (syntax_error):
* eval.c (syntax_error_2):
* eval.c (maybe_syntax_error):
* eval.c (sferror):
* eval.c (sferror_2):
* eval.c (maybe_sferror):
* eval.c (invalid_argument):
* eval.c (invalid_argument_2):
* eval.c (maybe_invalid_argument):
* eval.c (invalid_constant):
* eval.c (invalid_constant_2):
* eval.c (maybe_invalid_constant):
* eval.c (invalid_operation):
* eval.c (invalid_operation_2):
* eval.c (maybe_invalid_operation):
* eval.c (invalid_change):
* eval.c (invalid_change_2):
* eval.c (maybe_invalid_change):
* eval.c (invalid_state):
* eval.c (invalid_state_2):
* eval.c (maybe_invalid_state):
* eval.c (wtaerror):
* eval.c (stack_overflow):
* eval.c (out_of_memory):
* eval.c (print_multiple_value):
* eval.c (issue_call_trapping_problems_warning):
* eval.c (backtrace_specials):
* eval.c (backtrace_unevalled_args):
* eval.c (Fbacktrace):
* eval.c (warn_when_safe):
* event-Xt.c (modwarn):
* event-Xt.c (modbarf):
* event-Xt.c (check_modifier):
* event-Xt.c (store_modifier):
* event-Xt.c (emacs_Xt_format_magic_event):
* event-Xt.c (describe_event):
* event-gtk.c (dragndrop_data_received):
* event-gtk.c (store_modifier):
* event-gtk.c (gtk_reset_modifier_mapping):
* event-msw.c (dde_eval_string):
* event-msw.c (Fdde_alloc_advise_item):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (FROB):
* event-msw.c (emacs_mswindows_format_magic_event):
* event-stream.c (external_debugging_print_event):
* event-stream.c (execute_help_form):
* event-stream.c (vars_of_event_stream):
* events.c (print_event_1):
* events.c (print_event):
* events.c (event_equal):
* extents.c (print_extent_1):
* extents.c (print_extent):
* extents.c (vars_of_extents):
* faces.c (print_face):
* faces.c (complex_vars_of_faces):
* file-coding.c:
* file-coding.c (print_coding_system):
* file-coding.c (print_coding_system_in_print_method):
* file-coding.c (default_query_method):
* file-coding.c (find_coding_system):
* file-coding.c (make_coding_system_1):
* file-coding.c (chain_print):
* file-coding.c (undecided_print):
* file-coding.c (gzip_print):
* file-coding.c (vars_of_file_coding):
* file-coding.c (complex_vars_of_file_coding):
* fileio.c:
* fileio.c (report_file_type_error):
* fileio.c (report_error_with_errno):
* fileio.c (report_file_error):
* fileio.c (barf_or_query_if_file_exists):
* fileio.c (vars_of_fileio):
* floatfns.c (matherr):
* fns.c (print_bit_vector):
* fns.c (Fmapconcat):
* fns.c (add_suffix_to_symbol):
* fns.c (add_prefix_to_symbol):
* frame-gtk.c:
* frame-gtk.c (Fgtk_window_id):
* frame-x.c (def):
* frame-x.c (x_cde_transfer_callback):
* frame.c:
* frame.c (Fmake_frame):
* gc.c (show_gc_cursor_and_message):
* gc.c (vars_of_gc):
* glyphs-eimage.c (png_instantiate):
* glyphs-eimage.c (tiff_instantiate):
* glyphs-gtk.c (gtk_print_image_instance):
* glyphs-msw.c (mswindows_print_image_instance):
* glyphs-x.c (x_print_image_instance):
* glyphs-x.c (update_widget_face):
* glyphs.c (make_string_from_file):
* glyphs.c (print_image_instance):
* glyphs.c (signal_image_error):
* glyphs.c (signal_image_error_2):
* glyphs.c (signal_double_image_error):
* glyphs.c (signal_double_image_error_2):
* glyphs.c (xbm_mask_file_munging):
* glyphs.c (pixmap_to_lisp_data):
* glyphs.h:
* gui.c (gui_item_display_flush_left):
* hpplay.c (player_error_internal):
* hpplay.c (myHandler):
* intl-win32.c:
* intl-win32.c (langcode_to_lang):
* intl-win32.c (sublangcode_to_lang):
* intl-win32.c (Fmswindows_get_locale_info):
* intl-win32.c (lcid_to_locale_mule_or_no):
* intl-win32.c (mswindows_multibyte_to_unicode_print):
* intl-win32.c (complex_vars_of_intl_win32):
* keymap.c:
* keymap.c (print_keymap):
* keymap.c (ensure_meta_prefix_char_keymapp):
* keymap.c (Fkey_description):
* keymap.c (Ftext_char_description):
* lisp.h:
* lisp.h (struct):
* lisp.h (DECLARE_INLINE_HEADER):
* lread.c (Fload_internal):
* lread.c (locate_file):
* lread.c (read_escape):
* lread.c (read_raw_string):
* lread.c (read1):
* lread.c (read_list):
* lread.c (read_compiled_function):
* lread.c (init_lread):
* lrecord.h:
* marker.c (print_marker):
* marker.c (marker_equal):
* menubar-msw.c (displayable_menu_item):
* menubar-x.c (command_builder_operate_menu_accelerator):
* menubar.c (vars_of_menubar):
* minibuf.c (reinit_complex_vars_of_minibuf):
* minibuf.c (complex_vars_of_minibuf):
* mule-charset.c (Fmake_charset):
* mule-charset.c (complex_vars_of_mule_charset):
* mule-coding.c (iso2022_print):
* mule-coding.c (fixed_width_query):
* number.c (bignum_print):
* number.c (ratio_print):
* number.c (bigfloat_print):
* number.c (bigfloat_finalize):
* objects-msw.c:
* objects-msw.c (mswindows_color_to_string):
* objects-msw.c (mswindows_color_list):
* objects-tty.c:
* objects-tty.c (tty_font_list):
* objects-tty.c (tty_find_charset_font):
* objects-xlike-inc.c (xft_find_charset_font):
* objects-xlike-inc.c (endif):
* print.c:
* print.c (write_istring):
* print.c (write_ascstring):
* print.c (Fterpri):
* print.c (Fprint):
* print.c (print_error_message):
* print.c (print_vector_internal):
* print.c (print_cons):
* print.c (print_string):
* print.c (printing_unreadable_object):
* print.c (print_internal):
* print.c (print_float):
* print.c (print_symbol):
* process-nt.c (mswindows_report_winsock_error):
* process-nt.c (nt_canonicalize_host_name):
* process-unix.c (unix_canonicalize_host_name):
* process.c (print_process):
* process.c (report_process_error):
* process.c (report_network_error):
* process.c (make_process_internal):
* process.c (Fstart_process_internal):
* process.c (status_message):
* process.c (putenv_internal):
* process.c (vars_of_process):
* process.h:
* profile.c (vars_of_profile):
* rangetab.c (print_range_table):
* realpath.c (vars_of_realpath):
* redisplay.c (vars_of_redisplay):
* search.c (wordify):
* search.c (Freplace_match):
* sheap.c (sheap_adjust_h):
* sound.c (report_sound_error):
* sound.c (Fplay_sound_file):
* specifier.c (print_specifier):
* symbols.c (Fsubr_name):
* symbols.c (do_symval_forwarding):
* symbols.c (set_default_buffer_slot_variable):
* symbols.c (set_default_console_slot_variable):
* symbols.c (store_symval_forwarding):
* symbols.c (default_value):
* symbols.c (defsymbol_massage_name_1):
* symbols.c (defsymbol_massage_name_nodump):
* symbols.c (defsymbol_massage_name):
* symbols.c (defsymbol_massage_multiword_predicate_nodump):
* symbols.c (defsymbol_massage_multiword_predicate):
* symbols.c (defsymbol_nodump):
* symbols.c (defsymbol):
* symbols.c (defkeyword):
* symbols.c (defkeyword_massage_name):
* symbols.c (check_module_subr):
* symbols.c (deferror_1):
* symbols.c (deferror):
* symbols.c (deferror_massage_name):
* symbols.c (deferror_massage_name_and_message):
* symbols.c (defvar_magic):
* symeval.h:
* symeval.h (DEFVAR_SYMVAL_FWD):
* sysdep.c:
* sysdep.c (init_system_name):
* sysdll.c:
* sysdll.c (MAYBE_PREPEND_UNDERSCORE):
* sysdll.c (dll_function):
* sysdll.c (dll_variable):
* sysdll.c (dll_error):
* sysdll.c (dll_open):
* sysdll.c (dll_close):
* sysdll.c (image_for_address):
* sysdll.c (my_find_image):
* sysdll.c (search_linked_libs):
* sysdll.h:
* sysfile.h:
* sysfile.h (DEFAULT_DIRECTORY_FALLBACK):
* syswindows.h:
* tests.c (DFC_CHECK_LENGTH):
* tests.c (DFC_CHECK_CONTENT):
* tests.c (Ftest_hash_tables):
* text.c (vars_of_text):
* text.h:
* tooltalk.c (tt_opnum_string):
* tooltalk.c (tt_message_arg_ival_string):
* tooltalk.c (Ftooltalk_default_procid):
* tooltalk.c (Ftooltalk_default_session):
* tooltalk.c (init_tooltalk):
* tooltalk.c (vars_of_tooltalk):
* ui-gtk.c (Fdll_load):
* ui-gtk.c (type_to_marshaller_type):
* ui-gtk.c (Fgtk_import_function_internal):
* ui-gtk.c (emacs_gtk_object_printer):
* ui-gtk.c (emacs_gtk_boxed_printer):
* unicode.c (unicode_to_ichar):
* unicode.c (unicode_print):
* unicode.c (unicode_query):
* unicode.c (vars_of_unicode):
* unicode.c (complex_vars_of_unicode):
* win32.c:
* win32.c (mswindows_report_process_error):
* window.c (print_window):
* xemacs.def.in.in:
BASIC IDEA: Further fixing up uses of char * and CIbyte *
to reflect their actual semantics; Mule-izing some code;
redoing of the not-yet-working code to handle message translation.
Clean up code to handle message-translation (not yet working).
Create separate versions of build_msg_string() for working with
Ibyte *, CIbyte *, and Ascbyte * arguments. Assert that Ascbyte *
arguments are pure-ASCII. Make build_msg_string() be the same
as build_msg_ascstring(). Create same three versions of GETTEXT()
and DEFER_GETTEXT(). Also create build_defer_string() and
variants for the equivalent of DEFER_GETTEXT() when building a
string. Remove old CGETTEXT(). Clean up code where GETTEXT(),
DEFER_GETTEXT(), build_msg_string(), etc. was being called and
introduce some new calls to build_msg_string(), etc. Remove
GETTEXT() from calls to weird_doc() -- we assume that the
message snarfer knows about weird_doc(). Remove uses of
DEFER_GETTEXT() from error messages in sysdep.c and instead use
special comments /* @@@begin-snarf@@@ */ and /* @@@end-snarf@@@ */
that the message snarfer presumably knows about.
Create build_ascstring() and use it in many instances in place
of build_string(). The purpose of having Ascbyte * variants is
to make the code more self-documenting in terms of what sort of
semantics is expected for char * strings. In fact in the process
of looking for uses of build_string(), much improperly Mule-ized
was discovered.
Mule-ize a lot of code as described in previous paragraph,
e.g. in sysdep.c.
Make the error functions take Ascbyte * strings and fix up a
couple of places where non-pure-ASCII strings were being passed in
(file-coding.c, mule-coding.c, unicode.c). (It's debatable whether
we really need to make the error functions work this way. It
helps catch places where code is written in a way that message
translation won't work, but we may well never implement message
translation.)
Make staticpro() and friends take Ascbyte * strings instead of
raw char * strings. Create a const_Ascbyte_ptr dynarr type
to describe what's held by staticpro_names[] and friends,
create pdump descriptions for const_Ascbyte_ptr dynarrs, and
use them in place of specially-crafted staticpro descriptions.
Mule-ize certain other functions (e.g. x_event_name) by correcting
raw use of char * to Ascbyte *, Rawbyte * or another such type,
and raw use of char[] buffers to another type (usually Ascbyte[]).
Change many uses of write_c_string() to write_msg_string(),
write_ascstring(), etc.
Mule-ize emodules.c, emodules.h, sysdll.h.
Fix some un-Mule-ized code in intl-win32.c.
A comment in event-Xt.c and the limitations of the message
snarfer (make-msgfile or whatever) is presumably incorrect --
it should be smart enough to handle function calls spread over
more than one line. Clean up code in event-Xt.c that was
written awkwardly for this reason.
In config.h.in, instead of NEED_ERROR_CHECK_TYPES_INLINES,
create a more general XEMACS_DEFS_NEEDS_INLINE_DECLS to
indicate when inlined functions need to be declared in
xemacs.defs.in.in, and make use of it in xemacs.defs.in.in.
We need to do this because postgresql.c now calls qxestrdup(),
which is an inline function.
Make nconc2() and other such functions MODULE_API and put
them in xemacs.defs.in.in since postgresql.c now uses them.
Clean up indentation in lread.c and a few other places.
In text.h, document ASSERT_ASCTEXT_ASCII() and
ASSERT_ASCTEXT_ASCII_LEN(), group together the stand-in
encodings and add some more for DLL symbols, function and
variable names, etc.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Tue, 26 Jan 2010 23:22:30 -0600 |
| parents | 91b3d00e717f |
| children | 0d4c9d0f6a8d |
| rev | line source |
|---|---|
| 1318 | 1 /* Support for dynamic arrays. |
| 428 | 2 Copyright (C) 1993 Sun Microsystems, Inc. |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
3 Copyright (C) 2002, 2003, 2004, 2005, 2010 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: Not in FSF. */ | |
| 23 | |
| 24 /* Written by Ben Wing, December 1993. */ | |
| 25 | |
| 26 /* | |
| 27 | |
| 28 A "dynamic array" is a contiguous array of fixed-size elements where there | |
| 29 is no upper limit (except available memory) on the number of elements in the | |
| 30 array. Because the elements are maintained contiguously, space is used | |
| 31 efficiently (no per-element pointers necessary) and random access to a | |
| 32 particular element is in constant time. At any one point, the block of memory | |
| 33 that holds the array has an upper limit; if this limit is exceeded, the | |
| 34 memory is realloc()ed into a new array that is twice as big. Assuming that | |
| 35 the time to grow the array is on the order of the new size of the array | |
| 36 block, this scheme has a provably constant amortized time (i.e. average | |
| 37 time over all additions). | |
| 38 | |
| 39 When you add elements or retrieve elements, pointers are used. Note that | |
| 40 the element itself (of whatever size it is), and not the pointer to it, | |
| 41 is stored in the array; thus you do not have to allocate any heap memory | |
| 42 on your own. Also, returned pointers are only guaranteed to be valid | |
| 43 until the next operation that changes the length of the array. | |
| 44 | |
| 45 This is a container object. Declare a dynamic array of a specific type | |
| 46 as follows: | |
| 47 | |
| 2367 | 48 typedef struct |
| 49 { | |
| 50 Dynarr_declare (mytype); | |
| 51 } mytype_dynarr; | |
| 428 | 52 |
| 53 Use the following functions/macros: | |
| 54 | |
| 55 void *Dynarr_new(type) | |
| 56 [MACRO] Create a new dynamic-array object, with each element of the | |
| 57 specified type. The return value is cast to (type##_dynarr). | |
| 58 This requires following the convention that types are declared in | |
| 59 such a way that this type concatenation works. In particular, TYPE | |
| 60 must be a symbol, not an arbitrary C type. | |
| 61 | |
| 62 Dynarr_add(d, el) | |
| 63 [MACRO] Add an element to the end of a dynamic array. EL is a pointer | |
| 64 to the element; the element itself is stored in the array, however. | |
| 65 No function call is performed unless the array needs to be resized. | |
| 66 | |
| 67 Dynarr_add_many(d, base, len) | |
| 68 [MACRO] Add LEN elements to the end of the dynamic array. The elements | |
| 771 | 69 should be contiguous in memory, starting at BASE. If BASE if NULL, |
| 70 just make space for the elements; don't actually add them. | |
| 428 | 71 |
| 72 Dynarr_insert_many_at_start(d, base, len) | |
| 73 [MACRO] Append LEN elements to the beginning of the dynamic array. | |
| 74 The elements should be contiguous in memory, starting at BASE. | |
| 771 | 75 If BASE if NULL, just make space for the elements; don't actually |
| 76 add them. | |
| 428 | 77 |
| 78 Dynarr_insert_many(d, base, len, start) | |
| 79 Insert LEN elements to the dynamic array starting at position | |
| 80 START. The elements should be contiguous in memory, starting at BASE. | |
| 771 | 81 If BASE if NULL, just make space for the elements; don't actually |
| 82 add them. | |
| 83 | |
| 84 Dynarr_delete(d, i) | |
| 85 [MACRO] Delete an element from the dynamic array at position I. | |
| 86 | |
| 87 Dynarr_delete_many(d, start, len) | |
| 88 Delete LEN elements from the dynamic array starting at position | |
| 89 START. | |
| 90 | |
| 91 Dynarr_delete_by_pointer(d, p) | |
| 92 [MACRO] Delete an element from the dynamic array at pointer P, | |
| 93 which must point within the block of memory that stores the data. | |
| 94 P should be obtained using Dynarr_atp(). | |
| 428 | 95 |
| 96 int Dynarr_length(d) | |
| 97 [MACRO] Return the number of elements currently in a dynamic array. | |
| 98 | |
| 99 int Dynarr_largest(d) | |
| 100 [MACRO] Return the maximum value that Dynarr_length(d) would | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
101 ever have returned. This is used esp. in the redisplay code, |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
102 which reuses dynarrs for performance reasons. |
| 428 | 103 |
| 104 type Dynarr_at(d, i) | |
| 105 [MACRO] Return the element at the specified index (no bounds checking | |
| 106 done on the index). The element itself is returned, not a pointer | |
| 107 to it. | |
| 108 | |
| 109 type *Dynarr_atp(d, i) | |
| 110 [MACRO] Return a pointer to the element at the specified index (no | |
| 111 bounds checking done on the index). The pointer may not be valid | |
| 112 after an element is added to or removed from the array. | |
| 113 | |
| 114 Dynarr_reset(d) | |
| 115 [MACRO] Reset the length of a dynamic array to 0. | |
| 116 | |
| 117 Dynarr_free(d) | |
| 118 Destroy a dynamic array and the memory allocated to it. | |
| 119 | |
| 120 Use the following global variable: | |
| 121 | |
| 122 Dynarr_min_size | |
| 440 | 123 Minimum allowable size for a dynamic array when it is resized. |
| 428 | 124 |
| 125 */ | |
| 126 | |
| 127 #include <config.h> | |
| 128 #include "lisp.h" | |
| 129 | |
|
4952
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
130 static const struct memory_description const_Ascbyte_ptr_description_1[] = { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
131 { XD_ASCII_STRING, 0 }, |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
132 { XD_END } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
133 }; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
134 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
135 const struct sized_memory_description const_Ascbyte_ptr_description = { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
136 sizeof (const Ascbyte *), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
137 const_Ascbyte_ptr_description_1 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
138 }; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
139 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
140 static const struct memory_description const_Ascbyte_ptr_dynarr_description_1[] = { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
141 XD_DYNARR_DESC (const_Ascbyte_ptr_dynarr, &const_Ascbyte_ptr_description), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
142 { XD_END } |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
143 }; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
144 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
145 const struct sized_memory_description const_Ascbyte_ptr_dynarr_description = { |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
146 sizeof (const_Ascbyte_ptr_dynarr), |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
147 const_Ascbyte_ptr_dynarr_description_1 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
148 }; |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
149 |
|
19a72041c5ed
Mule-izing, various fixes related to char * arguments
Ben Wing <ben@xemacs.org>
parents:
4844
diff
changeset
|
150 |
| 440 | 151 static int Dynarr_min_size = 8; |
| 428 | 152 |
| 153 static void | |
| 3210 | 154 Dynarr_realloc (Dynarr *dy, int new_size) |
| 428 | 155 { |
| 156 if (DUMPEDP (dy->base)) | |
| 157 { | |
| 3293 | 158 void *new_base = malloc (new_size * dy->elsize); |
| 3210 | 159 memcpy (new_base, dy->base, |
| 160 (dy->max < new_size ? dy->max : new_size) * dy->elsize); | |
| 428 | 161 dy->base = new_base; |
| 162 } | |
| 163 else | |
| 3210 | 164 dy->base = xrealloc (dy->base, new_size * dy->elsize); |
| 428 | 165 } |
| 166 | |
| 167 void * | |
| 168 Dynarr_newf (int elsize) | |
| 169 { | |
| 170 Dynarr *d = xnew_and_zero (Dynarr); | |
| 171 d->elsize = elsize; | |
| 172 | |
| 173 return d; | |
| 174 } | |
| 175 | |
| 3092 | 176 #ifdef NEW_GC |
| 177 DEFINE_LRECORD_IMPLEMENTATION ("dynarr", dynarr, | |
| 178 1, /*dumpable-flag*/ | |
| 179 0, 0, 0, 0, 0, | |
| 180 0, | |
| 181 Dynarr); | |
| 182 | |
| 183 static void | |
| 3210 | 184 Dynarr_lisp_realloc (Dynarr *dy, int new_size) |
| 3092 | 185 { |
| 186 void *new_base = alloc_lrecord_array (dy->elsize, new_size, dy->lisp_imp); | |
| 187 if (dy->base) | |
| 188 memcpy (new_base, dy->base, | |
| 3210 | 189 (dy->max < new_size ? dy->max : new_size) * dy->elsize); |
| 3092 | 190 dy->base = new_base; |
| 191 } | |
| 192 | |
| 193 void * | |
| 194 Dynarr_lisp_newf (int elsize, | |
| 195 const struct lrecord_implementation *dynarr_imp, | |
| 196 const struct lrecord_implementation *imp) | |
| 197 { | |
| 198 Dynarr *d = (Dynarr *) alloc_lrecord (sizeof (Dynarr), dynarr_imp); | |
| 199 d->elsize = elsize; | |
| 200 d->lisp_imp = imp; | |
| 201 | |
| 202 return d; | |
| 203 } | |
| 204 #endif /* not NEW_GC */ | |
| 205 | |
| 428 | 206 void |
| 2367 | 207 Dynarr_resize (void *d, Elemcount size) |
| 428 | 208 { |
| 209 int newsize; | |
| 210 double multiplier; | |
| 1318 | 211 Dynarr *dy = (Dynarr *) Dynarr_verify (d); |
| 428 | 212 |
| 213 if (dy->max <= 8) | |
| 214 multiplier = 2; | |
| 215 else | |
| 216 multiplier = 1.5; | |
| 217 | |
| 218 for (newsize = dy->max; newsize < size;) | |
| 219 newsize = max (Dynarr_min_size, (int) (multiplier * newsize)); | |
| 220 | |
| 221 /* Don't do anything if the array is already big enough. */ | |
| 222 if (newsize > dy->max) | |
| 223 { | |
| 3092 | 224 #ifdef NEW_GC |
| 225 if (dy->lisp_imp) | |
| 226 Dynarr_lisp_realloc (dy, newsize); | |
| 227 else | |
| 3210 | 228 Dynarr_realloc (dy, newsize); |
| 3092 | 229 #else /* not NEW_GC */ |
| 3210 | 230 Dynarr_realloc (dy, newsize); |
| 3092 | 231 #endif /* not NEW_GC */ |
| 428 | 232 dy->max = newsize; |
| 233 } | |
| 234 } | |
| 235 | |
| 236 /* Add a number of contiguous elements to the array starting at START. */ | |
| 237 void | |
| 442 | 238 Dynarr_insert_many (void *d, const void *el, int len, int start) |
| 428 | 239 { |
| 793 | 240 Dynarr *dy = (Dynarr *) Dynarr_verify (d); |
| 241 | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
242 if (dy->len + len > dy->max) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
243 Dynarr_resize (dy, dy->len + len); |
| 1318 | 244 #if 0 |
| 245 /* WTF? We should be catching these problems. */ | |
| 428 | 246 /* Silently adjust start to be valid. */ |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
247 if (start > dy->len) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
248 start = dy->len; |
| 428 | 249 else if (start < 0) |
| 250 start = 0; | |
| 1318 | 251 #else |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
252 /* #### This could conceivably be wrong, if code wants to access stuff |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
253 between len and largest. */ |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
254 type_checking_assert (start >= 0 && start <= dy->len); |
| 1318 | 255 #endif |
| 428 | 256 |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
257 if (start != dy->len) |
| 428 | 258 { |
| 259 memmove ((char *) dy->base + (start + len)*dy->elsize, | |
| 260 (char *) dy->base + start*dy->elsize, | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
261 (dy->len - start)*dy->elsize); |
| 428 | 262 } |
| 771 | 263 if (el) |
| 264 memcpy ((char *) dy->base + start*dy->elsize, el, len*dy->elsize); | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
265 dy->len += len; |
| 428 | 266 |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
267 if (dy->len > dy->largest) |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
268 dy->largest = dy->len; |
| 428 | 269 } |
| 270 | |
| 271 void | |
| 272 Dynarr_delete_many (void *d, int start, int len) | |
| 273 { | |
| 1318 | 274 Dynarr *dy = (Dynarr *) Dynarr_verify (d); |
| 428 | 275 |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
276 type_checking_assert (start >= 0 && len >= 0 && start + len <= dy->len); |
| 428 | 277 memmove ((char *) dy->base + start*dy->elsize, |
| 278 (char *) dy->base + (start + len)*dy->elsize, | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
279 (dy->len - start - len)*dy->elsize); |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
280 dy->len -= len; |
| 428 | 281 } |
| 282 | |
| 283 void | |
| 284 Dynarr_free (void *d) | |
| 285 { | |
| 286 Dynarr *dy = (Dynarr *) d; | |
| 287 | |
| 3092 | 288 #ifdef NEW_GC |
| 289 if (dy->base && !DUMPEDP (dy->base)) | |
| 290 { | |
| 4117 | 291 if (!dy->lisp_imp) |
| 3092 | 292 xfree (dy->base, void *); |
| 293 } | |
| 294 if(!DUMPEDP (dy)) | |
| 295 { | |
| 4117 | 296 if (!dy->lisp_imp) |
| 3092 | 297 xfree (dy, Dynarr *); |
| 298 } | |
| 299 #else /* not NEW_GC */ | |
| 428 | 300 if (dy->base && !DUMPEDP (dy->base)) |
| 1726 | 301 xfree (dy->base, void *); |
| 428 | 302 if(!DUMPEDP (dy)) |
| 1726 | 303 xfree (dy, Dynarr *); |
| 3092 | 304 #endif /* not NEW_GC */ |
| 428 | 305 } |
| 306 | |
| 307 #ifdef MEMORY_USAGE_STATS | |
| 308 | |
| 309 /* Return memory usage for Dynarr D. The returned value is the total | |
| 310 amount of bytes actually being used for the Dynarr, including all | |
| 311 overhead. The extra amount of space in the Dynarr that is | |
| 312 allocated beyond what was requested is returned in DYNARR_OVERHEAD | |
| 313 in STATS. The extra amount of space that malloc() allocates beyond | |
| 314 what was requested of it is returned in MALLOC_OVERHEAD in STATS. | |
| 315 See the comment above the definition of this structure. */ | |
| 316 | |
| 665 | 317 Bytecount |
| 428 | 318 Dynarr_memory_usage (void *d, struct overhead_stats *stats) |
| 319 { | |
| 665 | 320 Bytecount total = 0; |
| 428 | 321 Dynarr *dy = (Dynarr *) d; |
| 322 | |
| 323 /* We have to be a bit tricky here because not all of the | |
| 324 memory that malloc() will claim as "requested" was actually | |
| 325 requested. */ | |
| 326 | |
| 327 if (dy->base) | |
| 328 { | |
| 665 | 329 Bytecount malloc_used = malloced_storage_size (dy->base, |
| 1318 | 330 dy->elsize * dy->max, 0); |
| 428 | 331 /* #### This may or may not be correct. Some Dynarrs would |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
332 prefer that we use dy->len instead of dy->largest here. */ |
| 1318 | 333 Bytecount was_requested = dy->elsize * dy->largest; |
| 334 Bytecount dynarr_overhead = dy->elsize * (dy->max - dy->largest); | |
| 428 | 335 |
| 336 total += malloc_used; | |
| 337 stats->was_requested += was_requested; | |
| 338 stats->dynarr_overhead += dynarr_overhead; | |
| 339 /* And the remainder must be malloc overhead. */ | |
| 340 stats->malloc_overhead += | |
| 341 malloc_used - was_requested - dynarr_overhead; | |
| 342 } | |
| 343 | |
| 344 total += malloced_storage_size (d, sizeof (*dy), stats); | |
| 345 | |
| 346 return total; | |
| 347 } | |
| 348 | |
| 349 #endif /* MEMORY_USAGE_STATS */ | |
| 2367 | 350 |
| 351 /* Version of malloc() that will be extremely efficient when allocation | |
| 352 nearly always occurs in LIFO (stack) order. | |
| 353 | |
| 354 #### Perhaps shouldn't be in this file, but where else? */ | |
| 355 | |
| 356 typedef struct | |
| 357 { | |
| 358 Dynarr_declare (char_dynarr *); | |
| 359 } char_dynarr_dynarr; | |
| 360 | |
| 361 char_dynarr_dynarr *stack_like_free_list; | |
| 362 char_dynarr_dynarr *stack_like_in_use_list; | |
| 363 | |
| 364 void * | |
| 365 stack_like_malloc (Bytecount size) | |
| 366 { | |
| 367 char_dynarr *this_one; | |
| 368 if (!stack_like_free_list) | |
| 369 { | |
| 370 stack_like_free_list = Dynarr_new2 (char_dynarr_dynarr, | |
| 371 char_dynarr *); | |
| 372 stack_like_in_use_list = Dynarr_new2 (char_dynarr_dynarr, | |
| 373 char_dynarr *); | |
| 374 } | |
| 375 | |
| 376 if (Dynarr_length (stack_like_free_list) > 0) | |
| 377 this_one = Dynarr_pop (stack_like_free_list); | |
| 378 else | |
| 379 this_one = Dynarr_new (char); | |
| 380 Dynarr_add (stack_like_in_use_list, this_one); | |
|
4844
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
381 Dynarr_reset (this_one); |
|
91b3d00e717f
Various cleanups for Dynarr code, from Unicode-internal ws
Ben Wing <ben@xemacs.org>
parents:
4117
diff
changeset
|
382 Dynarr_add_many (this_one, 0, size); |
| 2367 | 383 return Dynarr_atp (this_one, 0); |
| 384 } | |
| 385 | |
| 386 void | |
| 387 stack_like_free (void *val) | |
| 388 { | |
| 389 int len = Dynarr_length (stack_like_in_use_list); | |
| 390 assert (len > 0); | |
| 391 /* The vast majority of times, we will be called in a last-in first-out | |
| 392 order, and the item at the end of the list will be the one we're | |
| 393 looking for, so just check for this first and avoid any function | |
| 394 calls. */ | |
| 395 if (Dynarr_atp (Dynarr_at (stack_like_in_use_list, len - 1), 0) == val) | |
| 396 { | |
| 397 char_dynarr *this_one = Dynarr_pop (stack_like_in_use_list); | |
| 398 Dynarr_add (stack_like_free_list, this_one); | |
| 399 } | |
| 400 else | |
| 401 { | |
| 402 /* Find the item and delete it. */ | |
| 403 int i; | |
| 404 assert (len >= 2); | |
| 405 for (i = len - 2; i >= 0; i--) | |
| 406 if (Dynarr_atp (Dynarr_at (stack_like_in_use_list, i), 0) == | |
| 407 val) | |
| 408 { | |
| 409 char_dynarr *this_one = Dynarr_at (stack_like_in_use_list, i); | |
| 410 Dynarr_add (stack_like_free_list, this_one); | |
| 411 Dynarr_delete (stack_like_in_use_list, i); | |
| 412 return; | |
| 413 } | |
| 414 | |
| 2500 | 415 ABORT (); |
| 2367 | 416 } |
| 417 } |