comparison src/lrecord.h @ 2367:ecf1ebac70d8

[xemacs-hg @ 2004-11-04 23:05:23 by ben] commit mega-patch configure.in: Turn off -Winline and -Wchar-subscripts. Use the right set of cflags when compiling modules. Rewrite ldap configuration to separate the inclusion of lber (needed in recent Cygwin) from the basic checks for the needed libraries. add a function for MAKE_JUNK_C; initially code was added to generate xemacs.def using this, but it will need to be rewritten. add an rm -f for junk.c to avoid weird Cygwin bug with cp -f onto an existing file. Sort list of auto-detected functions and eliminate unused checks for stpcpy, setlocale and getwd. Add autodetection of Cygwin scanf problems BETA: Rewrite section on configure to indicate what flags are important and what not. digest-doc.c, make-dump-id.c, profile.c, sorted-doc.c: Add proper decls for main(). make-msgfile.c: Document that this is old junk. Move proposal to text.c. make-msgfile.lex: Move proposal to text.c. make-mswin-unicode.pl: Convert error-generating code so that the entire message will be seen as a single unrecognized token. mule/mule-ccl.el: Update docs. lispref/mule.texi: Update CCL docs. ldap/eldap.c: Mule-ize. Use EXTERNAL_LIST_LOOP_2 instead of deleted EXTERNAL_LIST_LOOP. * XEmacs 21.5.18 "chestnut" is released. --------------------------------------------------------------- MULE-RELATED WORK: --------------------------------------------------------------- --------------------------- byte-char conversion --------------------------- buffer.c, buffer.h, insdel.c, text.c: Port FSF algorithm for byte-char conversion, replacing broken previous version. Track the char position of the gap. Add functions to do char-byte conversion downwards as well as upwards. Move comments about algorithm workings to internals manual. --------------------------- work on types --------------------------- alloc.c, console-x-impl.h, dump-data.c, dump-data.h, dumper.c, dialog-msw.c, dired-msw.c, doc.c, editfns.c, esd.c, event-gtk.h, event-msw.c, events.c, file-coding.c, file-coding.h, fns.c, glyphs-eimage.c, glyphs-gtk.c, glyphs-msw.c, glyphs-shared.c, glyphs-x.c, glyphs.c, glyphs.h, gui.c, hpplay.c, imgproc.c, intl-win32.c, lrecord.h, lstream.c, keymap.c, lisp.h, libsst.c, linuxplay.c, miscplay.c, miscplay.h, mule-coding.c, nas.c, nt.c, ntheap.c, ntplay.c, objects-msw.c, objects-tty.c, objects-x.c, print.c, process-nt.c, process.c, redisplay.h, select-common.h, select-gtk.c, select-x.c, sgiplay.c, sound.c, sound.h, sunplay.c, sysfile.h, sysdep.c, syswindows.h, text.c, unexnt.c, win32.c, xgccache.c: Further work on types. This creates a full set of types for all the basic semantics of `char' that I have so far identified, so that its semantics can always be identified for the purposes of proper Mule-safe code, and the raw use of `char' always avoided. (1) More type renaming, for consistency of naming. Char_ASCII -> Ascbyte UChar_ASCII -> UAscbyte Char_Binary -> CBinbyte UChar_Binary -> Binbyte SChar_Binary -> SBinbyte (2) Introduce Rawbyte, CRawbyte, Boolbyte, Chbyte, UChbyte, and Bitbyte and use them. (3) New types Itext, Wexttext and Textcount for separating out the concepts of bytes and textual units (different under UTF-16 and UTF-32, which are potential internal encodings). (4) qxestr*_c -> qxestr*_ascii. lisp.h: New; goes with other qxe() functions. #### Maybe goes in a different section. lisp.h: Group generic int-type defs together with EMACS_INT defs. lisp.h: * lisp.h (WEXTTEXT_IS_WIDE) New defns. lisp.h: New type to replace places where int occurs as a boolean. It's signed because occasionally people may want to use -1 as an error value, and because unsigned ints are viral -- see comments in the internals manual against using them. dynarr.c: int -> Bytecount. --------------------------- Mule-izing --------------------------- device-x.c: Partially Mule-ize. dumper.c, dumper.h: Mule-ize. Use Rawbyte. Use stderr_out not printf. Use wext_*(). sysdep.c, syswindows.h, text.c: New Wexttext API for manipulation of external text that may be Unicode (e.g. startup code under Windows). emacs.c: Mule-ize. Properly deal with argv in external encoding. Use wext_*() and Wexttext. Use Rawbyte. #if 0 some old junk on SCO that is unlikely to be correct. Rewrite allocation code in run-temacs. emacs.c, symsinit.h, win32.c: Rename win32 init function and call it even earlier, to initialize mswindows_9x_p even earlier, for use in startup code (XEUNICODE_P). process.c: Use _wenviron not environ under Windows, to get Unicode environment variables. event-Xt.c: Mule-ize drag-n-drop related stuff. dragdrop.c, dragdrop.h, frame-x.c: Mule-ize. text.h: Add some more stand-in defines for particular kinds of conversion; use in Mule-ization work in frame-x.c etc. --------------------------- Freshening --------------------------- intl-auto-encap-win32.c, intl-auto-encap-win32.h: Regenerate. --------------------------- Unicode-work --------------------------- intl-win32.c, syswindows.h: Factor out common options to MultiByteToWideChar and WideCharToMultiByte. Add convert_unicode_to_multibyte_malloc() and convert_unicode_to_multibyte_dynarr() and use. Add stuff for alloca() conversion of multibyte/unicode. alloc.c: Use dfc_external_data_len() in case of unicode coding system. alloc.c, mule-charset.c: Don't zero out and reinit charset Unicode tables. This fucks up dump-time loading. Anyway, either we load them at dump time or run time, never both. unicode.c: Dump the blank tables as well. --------------------------------------------------------------- DOCUMENTATION, MOSTLY MULE-RELATED: --------------------------------------------------------------- EmacsFrame.c, emodules.c, event-Xt.c, fileio.c, input-method-xlib.c, mule-wnnfns.c, redisplay-gtk.c, redisplay-tty.c, redisplay-x.c, regex.c, sysdep.c: Add comment about Mule work needed. text.h: Add more documentation describing why DFC routines were not written to return their value. Add some other DFC documentation. console-msw.c, console-msw.h: Add pointer to docs in win32.c. emacs.c: Add comments on sources of doc info. text.c, charset.h, unicode.c, intl-win32.c, intl-encap-win32.c, text.h, file-coding.c, mule-coding.c: Collect background comments and related to text matters and internationalization, and proposals for work to be done, in text.c or Internals manual, stuff related to specific textual API's in text.h, and stuff related to internal implementation of Unicode conversion in unicode.c. Put lots of pointers to the comments to make them easier to find. s/mingw32.h, s/win32-common.h, s/win32-native.h, s/windowsnt.h, win32.c: Add bunches of new documentation on the different kinds of builds and environments under Windows and how they work. Collect this info in win32.c. Add pointers to these docs in the relevant s/* files. emacs.c: Document places with long comments. Remove comment about exiting, move to internals manual, put in pointer. event-stream.c: Move docs about event queues and focus to internals manual, put in pointer. events.h: Move docs about event stream callbacks to internals manual, put in pointer. profile.c, redisplay.c, signal.c: Move documentation to the Internals manual. process-nt.c: Add pointer to comment in win32-native.el. lisp.h: Add comments about some comment conventions. lisp.h: Add comment about the second argument. device-msw.c, redisplay-msw.c: @@#### comments are out-of-date. --------------------------------------------------------------- PDUMP WORK (MOTIVATED BY UNICODE CHANGES) --------------------------------------------------------------- alloc.c, buffer.c, bytecode.c, console-impl.h, console.c, device.c, dumper.c, lrecord.h, elhash.c, emodules.h, events.c, extents.c, frame.c, glyphs.c, glyphs.h, mule-charset.c, mule-coding.c, objects.c, profile.c, rangetab.c, redisplay.c, specifier.c, specifier.h, window.c, lstream.c, file-coding.h, file-coding.c: PDUMP: Properly implement dump_add_root_block(), which never worked before, and is necessary for dumping Unicode tables. Pdump name changes for accuracy: XD_STRUCT_PTR -> XD_BLOCK_PTR. XD_STRUCT_ARRAY -> XD_BLOCK_ARRAY. XD_C_STRING -> XD_ASCII_STRING. *_structure_* -> *_block_*. lrecord.h: some comments added about dump_add_root_block() vs dump_add_root_block_ptr(). extents.c: remove incorrect comment about pdump problems with gap array. --------------------------------------------------------------- ALLOCATION --------------------------------------------------------------- abbrev.c, alloc.c, bytecode.c, casefiddle.c, device-msw.c, device-x.c, dired-msw.c, doc.c, doprnt.c, dragdrop.c, editfns.c, emodules.c, file-coding.c, fileio.c, filelock.c, fns.c, glyphs-eimage.c, glyphs-gtk.c, glyphs-msw.c, glyphs-x.c, gui-msw.c, gui-x.c, imgproc.c, intl-win32.c, lread.c, menubar-gtk.c, menubar.c, nt.c, objects-msw.c, objects-x.c, print.c, process-nt.c, process-unix.c, process.c, realpath.c, redisplay.c, search.c, select-common.c, symbols.c, sysdep.c, syswindows.h, text.c, text.h, ui-byhand.c: New macros {alloca,xnew}_{itext,{i,ext,raw,bin,asc}bytes} for more convenient allocation of these commonly requested items. Modify functions to use alloca_ibytes, alloca_array, alloca_extbytes, xnew_ibytes, etc. also XREALLOC_ARRAY, xnew. alloc.c: Rewrite the allocation functions to factor out repeated code. Add assertions for freeing dumped data. lisp.h: Moved down and consolidated with other allocation stuff. lisp.h, dynarr.c: New functions for allocation that's very efficient when mostly in LIFO order. lisp.h, text.c, text.h: Factor out some stuff for general use by alloca()-conversion funs. text.h, lisp.h: Fill out convenience routines for allocating various kinds of bytes and put them in lisp.h. Use them in place of xmalloc(), ALLOCA(). text.h: Fill out the convenience functions so the _MALLOC() kinds match the alloca() kinds. --------------------------------------------------------------- ERROR-CHECKING --------------------------------------------------------------- text.h: Create ASSERT_ASCTEXT_ASCII() and ASSERT_ASCTEXT_ASCII_LEN() from similar Eistring checkers and change the Eistring checkers to use them instead. --------------------------------------------------------------- MACROS IN LISP.H --------------------------------------------------------------- lisp.h: Redo GCPRO declarations. Create a "base" set of functions that can be used to generate any kind of gcpro sets -- regular, ngcpro, nngcpro, private ones used in GC_EXTERNAL_LIST_LOOP_2. buffer.c, callint.c, chartab.c, console-msw.c, device-x.c, dialog-msw.c, dired.c, extents.c, ui-gtk.c, rangetab.c, nt.c, mule-coding.c, minibuf.c, menubar-msw.c, menubar.c, menubar-gtk.c, lread.c, lisp.h, gutter.c, glyphs.c, glyphs-widget.c, fns.c, fileio.c, file-coding.c, specifier.c: Eliminate EXTERNAL_LIST_LOOP, which does not check for circularities. Use EXTERNAL_LIST_LOOP_2 instead or EXTERNAL_LIST_LOOP_3 or EXTERNAL_PROPERTY_LIST_LOOP_3 or GC_EXTERNAL_LIST_LOOP_2 (new macro). Removed/redid comments on EXTERNAL_LIST_LOOP. --------------------------------------------------------------- SPACING FIXES --------------------------------------------------------------- callint.c, hftctl.c, number-gmp.c, process-unix.c: Spacing fixes. --------------------------------------------------------------- FIX FOR GEOMETRY PROBLEM IN FIRST FRAME --------------------------------------------------------------- unicode.c: Add workaround for newlib bug in sscanf() [should be fixed by release 1.5.12 of Cygwin]. toolbar.c: bug fix for problem of initial frame being 77 chars wide on Windows. will be overridden by my other ws. --------------------------------------------------------------- FIX FOR LEAKING PROCESS HANDLES: --------------------------------------------------------------- process-nt.c: Fixes for leaking handles. Inspired by work done by Adrian Aichner <adrian@xemacs.org>. --------------------------------------------------------------- FIX FOR CYGWIN BUG (Unicode-related): --------------------------------------------------------------- unicode.c: Add workaround for newlib bug in sscanf() [should be fixed by release 1.5.12 of Cygwin]. --------------------------------------------------------------- WARNING FIXES: --------------------------------------------------------------- console-stream.c: `reinit' is unused. compiler.h, event-msw.c, frame-msw.c, intl-encap-win32.c, text.h: Add stuff to deal with ANSI-aliasing warnings I got. regex.c: Gather includes together to avoid warning. --------------------------------------------------------------- CHANGES TO INITIALIZATION ROUTINES: --------------------------------------------------------------- buffer.c, emacs.c, console.c, debug.c, device-x.c, device.c, dragdrop.c, emodules.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-tty.c, events.c, extents.c, faces.c, file-coding.c, fileio.c, font-lock.c, frame-msw.c, glyphs-widget.c, glyphs.c, gui-x.c, insdel.c, lread.c, lstream.c, menubar-gtk.c, menubar-x.c, minibuf.c, mule-wnnfns.c, objects-msw.c, objects.c, print.c, scrollbar-x.c, search.c, select-x.c, text.c, undo.c, unicode.c, window.c, symsinit.h: Call reinit_*() functions directly from emacs.c, for clarity. Factor out some redundant init code. Move disallowed stuff that had crept into vars_of_glyphs() into complex_vars_of_glyphs(). Call init_eval_semi_early() from eval.c not in the middle of vars_of_() in emacs.c since there should be no order dependency in the latter calls. --------------------------------------------------------------- ARMAGEDDON: --------------------------------------------------------------- alloc.c, emacs.c, lisp.h, print.c: Rename inhibit_non_essential_printing_operations to inhibit_non_essential_conversion_operations. text.c: Assert on !inhibit_non_essential_conversion_operations. console-msw.c, print.c: Don't do conversion in SetConsoleTitle or FindWindow to avoid problems during armageddon. Put #errors for NON_ASCII_INTERNAL_FORMAT in places where problems would arise. --------------------------------------------------------------- CHANGES TO THE BUILD PROCEDURE: --------------------------------------------------------------- config.h.in, s/cxux.h, s/usg5-4-2.h, m/powerpc.h: Add comment about correct ordering of this file. Rearrange everything to follow this -- put all #undefs together and before the s&m files. Add undefs for HAVE_ALLOCA, C_ALLOCA, BROKEN_ALLOCA_IN_FUNCTION_CALLS, STACK_DIRECTION. Remove unused HAVE_STPCPY, HAVE_GETWD, HAVE_SETLOCALE. m/gec63.h: Deleted; totally broken, not used at all, not in FSF. m/7300.h, m/acorn.h, m/alliant-2800.h, m/alliant.h, m/altos.h, m/amdahl.h, m/apollo.h, m/att3b.h, m/aviion.h, m/celerity.h, m/clipper.h, m/cnvrgnt.h, m/convex.h, m/cydra5.h, m/delta.h, m/delta88k.h, m/dpx2.h, m/elxsi.h, m/ews4800r.h, m/gould.h, m/hp300bsd.h, m/hp800.h, m/hp9000s300.h, m/i860.h, m/ibmps2-aix.h, m/ibmrs6000.h, m/ibmrt-aix.h, m/ibmrt.h, m/intel386.h, m/iris4d.h, m/iris5d.h, m/iris6d.h, m/irist.h, m/isi-ov.h, m/luna88k.h, m/m68k.h, m/masscomp.h, m/mg1.h, m/mips-nec.h, m/mips-siemens.h, m/mips.h, m/news.h, m/nh3000.h, m/nh4000.h, m/ns32000.h, m/orion105.h, m/pfa50.h, m/plexus.h, m/pmax.h, m/powerpc.h, m/pyrmips.h, m/sequent-ptx.h, m/sequent.h, m/sgi-challenge.h, m/symmetry.h, m/tad68k.h, m/tahoe.h, m/targon31.h, m/tekxd88.h, m/template.h, m/tower32.h, m/tower32v3.h, m/ustation.h, m/vax.h, m/wicat.h, m/xps100.h: Delete C_ALLOCA, HAVE_ALLOCA, STACK_DIRECTION, BROKEN_ALLOCA_IN_FUNCTION_CALLS. All of this is auto-detected. When in doubt, I followed recent FSF sources, which also have these things deleted.
author ben
date Thu, 04 Nov 2004 23:08:28 +0000
parents 9c872f33ecbe
children de9952d2ed18
comparison
equal deleted inserted replaced
2366:2a392e0c390a 2367:ecf1ebac70d8
1 /* The "lrecord" structure (header of a compound lisp object). 1 /* The "lrecord" structure (header of a compound lisp object).
2 Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc. 2 Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
3 Copyright (C) 1996, 2001, 2002 Ben Wing. 3 Copyright (C) 1996, 2001, 2002, 2004 Ben Wing.
4 4
5 This file is part of XEmacs. 5 This file is part of XEmacs.
6 6
7 XEmacs is free software; you can redistribute it and/or modify it 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 8 under the terms of the GNU General Public License as published by the
18 along with XEmacs; see the file COPYING. If not, write to 18 along with XEmacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */ 20 Boston, MA 02111-1307, USA. */
21 21
22 /* Synched up with: Not in FSF. */ 22 /* Synched up with: Not in FSF. */
23
24 /* This file has been Mule-ized, Ben Wing, 10-13-04. */
23 25
24 #ifndef INCLUDED_lrecord_h_ 26 #ifndef INCLUDED_lrecord_h_
25 #define INCLUDED_lrecord_h_ 27 #define INCLUDED_lrecord_h_
26 28
27 /* The "lrecord" type of Lisp object is used for all object types 29 /* The "lrecord" type of Lisp object is used for all object types
225 227
226 extern MODULE_API int lrecord_type_count; 228 extern MODULE_API int lrecord_type_count;
227 229
228 struct lrecord_implementation 230 struct lrecord_implementation
229 { 231 {
230 const char *name; 232 const Ascbyte *name;
231 233
232 /* information for the dumper: is the object dumpable and should it 234 /* information for the dumper: is the object dumpable and should it
233 be dumped. */ 235 be dumped. */
234 unsigned int dumpable :1; 236 unsigned int dumpable :1;
235 237
392 394
393 Descriptions are used by pdump in three places: (a) descriptions of Lisp 395 Descriptions are used by pdump in three places: (a) descriptions of Lisp
394 objects, referenced in the DEFINE_*LRECORD_*IMPLEMENTATION*() call; (b) 396 objects, referenced in the DEFINE_*LRECORD_*IMPLEMENTATION*() call; (b)
395 descriptions of global objects to be dumped, registered by 397 descriptions of global objects to be dumped, registered by
396 dump_add_root_block(); (c) descriptions of global pointers to 398 dump_add_root_block(); (c) descriptions of global pointers to
397 non-Lisp_Object heap objects, registered by dump_add_root_struct_ptr(). 399 non-Lisp_Object heap objects, registered by dump_add_root_block_ptr().
398 The descriptions need to tell pdump which elements of your structure are 400 The descriptions need to tell pdump which elements of your structure are
399 Lisp_Objects or structure pointers, plus the descriptions in turn of the 401 Lisp_Objects or structure pointers, plus the descriptions in turn of the
400 non-Lisp_Object structures pointed to. If these structures are you own 402 non-Lisp_Object structures pointed to. If these structures are you own
401 private ones, you will have to write these recursive descriptions 403 private ones, you will have to write these recursive descriptions
402 yourself; otherwise, you are reusing a structure already in existence 404 yourself; otherwise, you are reusing a structure already in existence
444 memory_descriptions are used to describe lrecords (the size of the 446 memory_descriptions are used to describe lrecords (the size of the
445 lrecord is elsewhere in its description, attached to its methods, so it 447 lrecord is elsewhere in its description, attached to its methods, so it
446 does not need to be given here) and global objects, where the size is an 448 does not need to be given here) and global objects, where the size is an
447 argument to the call to dump_add_root_block(). 449 argument to the call to dump_add_root_block().
448 sized_memory_descriptions are used for pointers and arrays in 450 sized_memory_descriptions are used for pointers and arrays in
449 memory_descriptions and for calls to dump_add_root_struct_ptr(). (#### 451 memory_descriptions and for calls to dump_add_root_block_ptr(). (####
450 It is not obvious why this is so in the latter case. Probably, calls to 452 It is not obvious why this is so in the latter case. Probably, calls to
451 dump_add_root_struct_ptr() should use plain memory_descriptions and have 453 dump_add_root_block_ptr() should use plain memory_descriptions and have
452 the size be an argument to the call.) 454 the size be an argument to the call.)
453 455
454 NOTE: Anywhere that a sized_memory_description occurs inside of a plain 456 NOTE: Anywhere that a sized_memory_description occurs inside of a plain
455 memory_description, a "description map" can be substituted. Rather than 457 memory_description, a "description map" can be substituted. Rather than
456 being an actual description, this describes how to find the description 458 being an actual description, this describes how to find the description
495 int count; 497 int count;
496 Lisp_Object *objects; 498 Lisp_Object *objects;
497 ...; 499 ...;
498 } 500 }
499 501
500 You'd use XD_STRUCT_PTR, something like: 502 You'd use XD_BLOCK_PTR, something like:
501 503
502 static const struct memory_description foo_description[] = { 504 static const struct memory_description foo_description[] = {
503 ... 505 ...
504 { XD_INT, offsetof (Lisp_Foo, count) }, 506 { XD_INT, offsetof (Lisp_Foo, count) },
505 { XD_STRUCT_PTR, offsetof (Lisp_Foo, objects), 507 { XD_BLOCK_PTR, offsetof (Lisp_Foo, objects),
506 XD_INDIRECT (0, 0), &lisp_object_description }, 508 XD_INDIRECT (0, 0), &lisp_object_description },
507 ... 509 ...
508 }; 510 };
509 511
510 lisp_object_description is declared in alloc.c, like this: 512 lisp_object_description is declared in alloc.c, like this:
517 const struct sized_memory_description lisp_object_description = { 519 const struct sized_memory_description lisp_object_description = {
518 sizeof (Lisp_Object), 520 sizeof (Lisp_Object),
519 lisp_object_description_1 521 lisp_object_description_1
520 }; 522 };
521 523
522 Another example of XD_STRUCT_PTR: 524 Another example of XD_BLOCK_PTR:
523 525
524 typedef struct htentry 526 typedef struct htentry
525 { 527 {
526 Lisp_Object key; 528 Lisp_Object key;
527 Lisp_Object value; 529 Lisp_Object value;
555 htentry_description_1 557 htentry_description_1
556 }; 558 };
557 559
558 const struct memory_description hash_table_description[] = { 560 const struct memory_description hash_table_description[] = {
559 { XD_ELEMCOUNT, offsetof (Lisp_Hash_Table, size) }, 561 { XD_ELEMCOUNT, offsetof (Lisp_Hash_Table, size) },
560 { XD_STRUCT_PTR, offsetof (Lisp_Hash_Table, hentries), XD_INDIRECT (0, 1), 562 { XD_BLOCK_PTR, offsetof (Lisp_Hash_Table, hentries), XD_INDIRECT (0, 1),
561 &htentry_description }, 563 &htentry_description },
562 { XD_LO_LINK, offsetof (Lisp_Hash_Table, next_weak) }, 564 { XD_LO_LINK, offsetof (Lisp_Hash_Table, next_weak) },
563 { XD_END } 565 { XD_END }
564 }; 566 };
565 567
575 { -1 } 577 { -1 }
576 }; 578 };
577 579
578 const struct memory_description specifier_description[] = { 580 const struct memory_description specifier_description[] = {
579 ... 581 ...
580 { XD_STRUCT_ARRAY, offset (Lisp_Specifier, data), 1, 582 { XD_BLOCK_ARRAY, offset (Lisp_Specifier, data), 1,
581 specifier_extra_description_map }, 583 specifier_extra_description_map },
582 ... 584 ...
583 { XD_END } 585 { XD_END }
584 }; 586 };
585 587
625 XD_LISP_OBJECT_ARRAY 627 XD_LISP_OBJECT_ARRAY
626 628
627 An array of Lisp objects or (equivalently) pointers to lrecords. 629 An array of Lisp objects or (equivalently) pointers to lrecords.
628 The parameter (i.e. third element) is the count. This would be declared 630 The parameter (i.e. third element) is the count. This would be declared
629 as Lisp_Object foo[666]. For something declared as Lisp_Object *foo, 631 as Lisp_Object foo[666]. For something declared as Lisp_Object *foo,
630 use XD_STRUCT_PTR, whose description parameter is a sized_memory_description 632 use XD_BLOCK_PTR, whose description parameter is a sized_memory_description
631 consisting of only XD_LISP_OBJECT and XD_END. 633 consisting of only XD_LISP_OBJECT and XD_END.
632 634
633 XD_LO_LINK 635 XD_LO_LINK
634 636
635 Weak link in a linked list of objects of the same type. This is a 637 Weak link in a linked list of objects of the same type. This is a
644 646
645 XD_OPAQUE_PTR 647 XD_OPAQUE_PTR
646 648
647 Pointer to undumpable data. Must be NULL when dumping. 649 Pointer to undumpable data. Must be NULL when dumping.
648 650
649 XD_STRUCT_PTR 651 XD_BLOCK_PTR
650 652
651 Pointer to block of described memory. (This is misnamed: It is NOT 653 Pointer to block of described memory. (This is misnamed: It is NOT
652 necessarily a pointer to a struct foo.) Parameters are number of 654 necessarily a pointer to a struct foo.) Parameters are number of
653 contiguous blocks and sized_memory_description. 655 contiguous blocks and sized_memory_description.
654 656
655 XD_STRUCT_ARRAY 657 XD_BLOCK_ARRAY
656 658
657 Array of blocks of described memory. Parameters are number of 659 Array of blocks of described memory. Parameters are number of
658 structures and sized_memory_description. This differs from XD_STRUCT_PTR 660 structures and sized_memory_description. This differs from XD_BLOCK_PTR
659 in that the parameter is declared as struct foo[666] instead of 661 in that the parameter is declared as struct foo[666] instead of
660 struct *foo. In other words, the block of memory holding the 662 struct *foo. In other words, the block of memory holding the
661 structures is within the containing structure, rather than being 663 structures is within the containing structure, rather than being
662 elsewhere, with a pointer in the containing structure. 664 elsewhere, with a pointer in the containing structure.
663 665
664 NOTE NOTE NOTE: Be sure that you understand the difference between 666 NOTE NOTE NOTE: Be sure that you understand the difference between
665 XD_STRUCT_PTR and XD_STRUCT_ARRAY: 667 XD_BLOCK_PTR and XD_BLOCK_ARRAY:
666 - struct foo bar[666], i.e. 666 inline struct foos 668 - struct foo bar[666], i.e. 666 inline struct foos
667 --> XD_STRUCT_ARRAY, argument 666, pointing to a description of 669 --> XD_BLOCK_ARRAY, argument 666, pointing to a description of
668 struct foo 670 struct foo
669 - struct foo *bar, i.e. pointer to a block of 666 struct foos 671 - struct foo *bar, i.e. pointer to a block of 666 struct foos
670 --> XD_STRUCT_PTR, argument 666, pointing to a description of 672 --> XD_BLOCK_PTR, argument 666, pointing to a description of
671 struct foo 673 struct foo
672 - struct foo *bar[666], i.e. 666 pointers to separate blocks of struct foos 674 - struct foo *bar[666], i.e. 666 pointers to separate blocks of struct foos
673 --> XD_STRUCT_ARRAY, argument 666, pointing to a description of 675 --> XD_BLOCK_ARRAY, argument 666, pointing to a description of
674 a single pointer to struct foo; the description is a single 676 a single pointer to struct foo; the description is a single
675 XD_STRUCT_PTR, argument 1, which in turn points to a description 677 XD_BLOCK_PTR, argument 1, which in turn points to a description
676 of struct foo. 678 of struct foo.
679
680 NOTE also that an XD_BLOCK_PTR of 666 foos is equivalent to an
681 XD_BLOCK_PTR of 1 bar, where the description of `bar' is an
682 XD_BLOCK_ARRAY of 666 foos.
677 683
678 XD_OPAQUE_DATA_PTR 684 XD_OPAQUE_DATA_PTR
679 685
680 Pointer to dumpable opaque data. Parameter is the size of the data. 686 Pointer to dumpable opaque data. Parameter is the size of the data.
681 Pointed data must be relocatable without changes. 687 Pointed data must be relocatable without changes.
691 is referred to as a "union map" and has a special interpretation: The 697 is referred to as a "union map" and has a special interpretation: The
692 offset field is replaced by a constant, which is compared to the first 698 offset field is replaced by a constant, which is compared to the first
693 parameter of the XD_UNION descriptor to determine if this description 699 parameter of the XD_UNION descriptor to determine if this description
694 applies to the union data, and XD_INDIRECT references refer to the 700 applies to the union data, and XD_INDIRECT references refer to the
695 containing object and description. Note that the description applies 701 containing object and description. Note that the description applies
696 "inline" to the union data, like XD_STRUCT_ARRAY and not XD_STRUCT_PTR. 702 "inline" to the union data, like XD_BLOCK_ARRAY and not XD_BLOCK_PTR.
697 If the union data is a pointer to different types of structures, each 703 If the union data is a pointer to different types of structures, each
698 element in the memory_description should be an XD_STRUCT_PTR. See 704 element in the memory_description should be an XD_BLOCK_PTR. See
699 unicode.c, redisplay.c and objects.c for examples of XD_UNION. 705 unicode.c, redisplay.c and objects.c for examples of XD_UNION.
700 706
701 XD_UNION_DYNAMIC_SIZE 707 XD_UNION_DYNAMIC_SIZE
702 708
703 Same as XD_UNION except that this is used for objects where the size of 709 Same as XD_UNION except that this is used for objects where the size of
704 the object containing the union varies depending on the particular value 710 the object containing the union varies depending on the particular value
705 of the union constant. That is, an object with plain XD_UNION typically 711 of the union constant. That is, an object with plain XD_UNION typically
706 has the union declared as `union foo' or as `void *', where an object 712 has the union declared as `union foo' or as `void *', where an object
707 with XD_UNION_DYNAMIC_SIZE typically has the union as the last element, 713 with XD_UNION_DYNAMIC_SIZE typically has the union as the last element,
708 and declared as something like char foo[1]. With plain XD_UNION, the 714 and declared as something like Rawbyte foo[1]. With plain XD_UNION, the
709 object is (usually) of fixed size and always contains enough space for 715 object is (usually) of fixed size and always contains enough space for
710 the data associated with all possible union constants, and thus the union 716 the data associated with all possible union constants, and thus the union
711 constant can potentially change during the lifetime of the object. With 717 constant can potentially change during the lifetime of the object. With
712 XD_UNION_DYNAMIC_SIZE, however, the union constant is fixed at the time 718 XD_UNION_DYNAMIC_SIZE, however, the union constant is fixed at the time
713 of creation of the object, and the size of the object is computed 719 of creation of the object, and the size of the object is computed
721 max size of the data associated with all possible union constants, 727 max size of the data associated with all possible union constants,
722 whereas the size of XD_UNION_DYNAMIC_SIZE comes from the size of the data 728 whereas the size of XD_UNION_DYNAMIC_SIZE comes from the size of the data
723 associated with the currently specified (and unchangeable) union 729 associated with the currently specified (and unchangeable) union
724 constant. 730 constant.
725 731
726 XD_C_STRING 732 XD_ASCII_STRING
727 733
728 Pointer to a C string. 734 Pointer to a C string, purely ASCII.
729 735
730 XD_DOC_STRING 736 XD_DOC_STRING
731 737
732 Pointer to a doc string (C string if positive, opaque value if negative) 738 Pointer to a doc string (C string in pure ASCII if positive,
739 opaque value if negative)
733 740
734 XD_INT_RESET 741 XD_INT_RESET
735 742
736 An integer which will be reset to a given value in the dump file. 743 An integer which will be reset to a given value in the dump file.
737 744
777 { 784 {
778 XD_LISP_OBJECT_ARRAY, 785 XD_LISP_OBJECT_ARRAY,
779 XD_LISP_OBJECT, 786 XD_LISP_OBJECT,
780 XD_LO_LINK, 787 XD_LO_LINK,
781 XD_OPAQUE_PTR, 788 XD_OPAQUE_PTR,
782 XD_STRUCT_PTR, 789 XD_BLOCK_PTR,
783 XD_STRUCT_ARRAY, 790 XD_BLOCK_ARRAY,
784 XD_OPAQUE_DATA_PTR, 791 XD_OPAQUE_DATA_PTR,
785 XD_UNION, 792 XD_UNION,
786 XD_UNION_DYNAMIC_SIZE, 793 XD_UNION_DYNAMIC_SIZE,
787 XD_C_STRING, 794 XD_ASCII_STRING,
788 XD_DOC_STRING, 795 XD_DOC_STRING,
789 XD_INT_RESET, 796 XD_INT_RESET,
790 XD_BYTECOUNT, 797 XD_BYTECOUNT,
791 XD_ELEMCOUNT, 798 XD_ELEMCOUNT,
792 XD_HASHCODE, 799 XD_HASHCODE,
864 #define XD_IS_INDIRECT(code) ((code) < 0) 871 #define XD_IS_INDIRECT(code) ((code) < 0)
865 #define XD_INDIRECT_VAL(code) ((-1 - (code)) & 255) 872 #define XD_INDIRECT_VAL(code) ((-1 - (code)) & 255)
866 #define XD_INDIRECT_DELTA(code) ((-1 - (code)) >> 8) 873 #define XD_INDIRECT_DELTA(code) ((-1 - (code)) >> 8)
867 874
868 #define XD_DYNARR_DESC(base_type, sub_desc) \ 875 #define XD_DYNARR_DESC(base_type, sub_desc) \
869 { XD_STRUCT_PTR, offsetof (base_type, base), XD_INDIRECT(1, 0), sub_desc }, \ 876 { XD_BLOCK_PTR, offsetof (base_type, base), XD_INDIRECT(1, 0), sub_desc }, \
870 { XD_INT, offsetof (base_type, cur) }, \ 877 { XD_INT, offsetof (base_type, cur) }, \
871 { XD_INT_RESET, offsetof (base_type, max), XD_INDIRECT(1, 0) } \ 878 { XD_INT_RESET, offsetof (base_type, max), XD_INDIRECT(1, 0) } \
872 879
873 880
874 /* DEFINE_LRECORD_IMPLEMENTATION is for objects with constant size. 881 /* DEFINE_LRECORD_IMPLEMENTATION is for objects with constant size.
1152 1159
1153 # define DECLARE_LRECORD(c_name, structtype) \ 1160 # define DECLARE_LRECORD(c_name, structtype) \
1154 extern const struct lrecord_implementation lrecord_##c_name; \ 1161 extern const struct lrecord_implementation lrecord_##c_name; \
1155 DECLARE_INLINE_HEADER ( \ 1162 DECLARE_INLINE_HEADER ( \
1156 structtype * \ 1163 structtype * \
1157 error_check_##c_name (Lisp_Object obj, const char *file, int line) \ 1164 error_check_##c_name (Lisp_Object obj, const Ascbyte *file, int line) \
1158 ) \ 1165 ) \
1159 { \ 1166 { \
1160 assert_at_line (RECORD_TYPEP (obj, lrecord_type_##c_name), file, line); \ 1167 assert_at_line (RECORD_TYPEP (obj, lrecord_type_##c_name), file, line); \
1161 return (structtype *) XPNTR (obj); \ 1168 return (structtype *) XPNTR (obj); \
1162 } \ 1169 } \
1164 1171
1165 # define DECLARE_MODULE_API_LRECORD(c_name, structtype) \ 1172 # define DECLARE_MODULE_API_LRECORD(c_name, structtype) \
1166 extern MODULE_API const struct lrecord_implementation lrecord_##c_name; \ 1173 extern MODULE_API const struct lrecord_implementation lrecord_##c_name; \
1167 DECLARE_INLINE_HEADER ( \ 1174 DECLARE_INLINE_HEADER ( \
1168 structtype * \ 1175 structtype * \
1169 error_check_##c_name (Lisp_Object obj, const char *file, int line) \ 1176 error_check_##c_name (Lisp_Object obj, const Ascbyte *file, int line) \
1170 ) \ 1177 ) \
1171 { \ 1178 { \
1172 assert_at_line (RECORD_TYPEP (obj, lrecord_type_##c_name), file, line); \ 1179 assert_at_line (RECORD_TYPEP (obj, lrecord_type_##c_name), file, line); \
1173 return (structtype *) XPNTR (obj); \ 1180 return (structtype *) XPNTR (obj); \
1174 } \ 1181 } \
1177 # define DECLARE_EXTERNAL_LRECORD(c_name, structtype) \ 1184 # define DECLARE_EXTERNAL_LRECORD(c_name, structtype) \
1178 extern int lrecord_type_##c_name; \ 1185 extern int lrecord_type_##c_name; \
1179 extern struct lrecord_implementation lrecord_##c_name; \ 1186 extern struct lrecord_implementation lrecord_##c_name; \
1180 DECLARE_INLINE_HEADER ( \ 1187 DECLARE_INLINE_HEADER ( \
1181 structtype * \ 1188 structtype * \
1182 error_check_##c_name (Lisp_Object obj, const char *file, int line) \ 1189 error_check_##c_name (Lisp_Object obj, const Ascbyte *file, int line) \
1183 ) \ 1190 ) \
1184 { \ 1191 { \
1185 assert_at_line (RECORD_TYPEP (obj, lrecord_type_##c_name), file, line); \ 1192 assert_at_line (RECORD_TYPEP (obj, lrecord_type_##c_name), file, line); \
1186 return (structtype *) XPNTR (obj); \ 1193 return (structtype *) XPNTR (obj); \
1187 } \ 1194 } \
1188 extern Lisp_Object Q##c_name##p 1195 extern Lisp_Object Q##c_name##p
1189 1196
1190 # define DECLARE_NONRECORD(c_name, type_enum, structtype) \ 1197 # define DECLARE_NONRECORD(c_name, type_enum, structtype) \
1191 DECLARE_INLINE_HEADER ( \ 1198 DECLARE_INLINE_HEADER ( \
1192 structtype * \ 1199 structtype * \
1193 error_check_##c_name (Lisp_Object obj, const char *file, int line) \ 1200 error_check_##c_name (Lisp_Object obj, const Ascbyte *file, int line) \
1194 ) \ 1201 ) \
1195 { \ 1202 { \
1196 assert_at_line (XTYPE (obj) == type_enum, file, line); \ 1203 assert_at_line (XTYPE (obj) == type_enum, file, line); \
1197 return (structtype *) XPNTR (obj); \ 1204 return (structtype *) XPNTR (obj); \
1198 } \ 1205 } \
1203 # define XNONRECORD(x, c_name, type_enum, structtype) \ 1210 # define XNONRECORD(x, c_name, type_enum, structtype) \
1204 error_check_##c_name (x, __FILE__, __LINE__) 1211 error_check_##c_name (x, __FILE__, __LINE__)
1205 1212
1206 DECLARE_INLINE_HEADER ( 1213 DECLARE_INLINE_HEADER (
1207 Lisp_Object 1214 Lisp_Object
1208 wrap_record_1 (const void *ptr, enum lrecord_type ty, const char *file, 1215 wrap_record_1 (const void *ptr, enum lrecord_type ty, const Ascbyte *file,
1209 int line) 1216 int line)
1210 ) 1217 )
1211 { 1218 {
1212 Lisp_Object obj = wrap_pointer_1 (ptr); 1219 Lisp_Object obj = wrap_pointer_1 (ptr);
1213 1220
1400 1407
1401 /* Copy the data from one lcrecord structure into another, but don't 1408 /* Copy the data from one lcrecord structure into another, but don't
1402 overwrite the header information. */ 1409 overwrite the header information. */
1403 1410
1404 #define copy_sized_lcrecord(dst, src, size) \ 1411 #define copy_sized_lcrecord(dst, src, size) \
1405 memcpy ((char *) (dst) + sizeof (struct lcrecord_header), \ 1412 memcpy ((Rawbyte *) (dst) + sizeof (struct lcrecord_header), \
1406 (char *) (src) + sizeof (struct lcrecord_header), \ 1413 (Rawbyte *) (src) + sizeof (struct lcrecord_header), \
1407 (size) - sizeof (struct lcrecord_header)) 1414 (size) - sizeof (struct lcrecord_header))
1408 1415
1409 #define copy_lcrecord(dst, src) copy_sized_lcrecord (dst, src, sizeof (*(dst))) 1416 #define copy_lcrecord(dst, src) copy_sized_lcrecord (dst, src, sizeof (*(dst)))
1410 1417
1411 #define zero_sized_lcrecord(lcr, size) \ 1418 #define zero_sized_lcrecord(lcr, size) \
1412 memset ((char *) (lcr) + sizeof (struct lcrecord_header), 0, \ 1419 memset ((Rawbyte *) (lcr) + sizeof (struct lcrecord_header), 0, \
1413 (size) - sizeof (struct lcrecord_header)) 1420 (size) - sizeof (struct lcrecord_header))
1414 1421
1415 #define zero_lcrecord(lcr) zero_sized_lcrecord (lcr, sizeof (*(lcr))) 1422 #define zero_lcrecord(lcr) zero_sized_lcrecord (lcr, sizeof (*(lcr)))
1416 1423
1417 DECLARE_INLINE_HEADER ( 1424 DECLARE_INLINE_HEADER (
1437 1444
1438 /************************************************************************/ 1445 /************************************************************************/
1439 /* Dumping */ 1446 /* Dumping */
1440 /************************************************************************/ 1447 /************************************************************************/
1441 1448
1442 /* dump_add_root_struct_ptr (&var, &desc) dumps the structure pointed to by 1449 /* dump_add_root_block_ptr (&var, &desc) dumps the structure pointed to by
1443 `var'. This is for a single relocatable pointer located in the data 1450 `var'. This is for a single relocatable pointer located in the data
1444 segment (i.e. the block pointed to is in the heap). */ 1451 segment (i.e. the block pointed to is in the heap).
1452
1453 If the structure pointed to is not a `struct' but an array, you should
1454 set the size field of the sized_memory_description to 0, and use
1455 XD_BLOCK_ARRAY in the inner memory_description.
1456
1457 NOTE that a "root struct pointer" could also be described using
1458 dump_add_root_block(), with SIZE == sizeof (void *), and a description
1459 containing a single XD_BLOCK_PTR entry, offset 0, size 1, with a
1460 structure description the same as the value passed to
1461 dump_add_root_block_ptr(). That would require an extra level of
1462 description, though, as compared to using dump_add_root_block_ptr(),
1463 and thus this function is generally more convenient.
1464 */
1445 #ifdef PDUMP 1465 #ifdef PDUMP
1446 void dump_add_root_struct_ptr (void *, const struct sized_memory_description *); 1466 void dump_add_root_block_ptr (void *, const struct sized_memory_description *);
1447 #else 1467 #else
1448 #define dump_add_root_struct_ptr(varaddr,descaddr) DO_NOTHING 1468 #define dump_add_root_block_ptr(varaddr, descaddr) DO_NOTHING
1449 #endif 1469 #endif
1450 1470
1451 /* dump_add_opaque (&var, size) dumps the opaque static structure `var'. 1471 /* dump_add_opaque (&var, size) dumps the opaque static structure `var'.
1452 This is for a static block of memory (in the data segment, not the 1472 This is for a static block of memory (in the data segment, not the
1453 heap), with no relocatable pointers in it. */ 1473 heap), with no relocatable pointers in it. */
1463 relocatable pointers in it. */ 1483 relocatable pointers in it. */
1464 #ifdef PDUMP 1484 #ifdef PDUMP
1465 void dump_add_root_block (const void *ptraddress, Bytecount size, 1485 void dump_add_root_block (const void *ptraddress, Bytecount size,
1466 const struct memory_description *desc); 1486 const struct memory_description *desc);
1467 #else 1487 #else
1468 #define dump_add_root_block(ptraddress,desc) DO_NOTHING 1488 #define dump_add_root_block(ptraddress, size, desc) DO_NOTHING
1469 #endif 1489 #endif
1470 1490
1471 /* Call dump_add_opaque_int (&int_var) to dump `int_var', of type `int'. */ 1491 /* Call dump_add_opaque_int (&int_var) to dump `int_var', of type `int'. */
1472 #ifdef PDUMP 1492 #ifdef PDUMP
1473 #define dump_add_opaque_int(int_varaddr) do { \ 1493 #define dump_add_opaque_int(int_varaddr) do { \
1510 Used during startup to detect startup of dumped Emacs. */ 1530 Used during startup to detect startup of dumped Emacs. */
1511 extern MODULE_API int initialized; 1531 extern MODULE_API int initialized;
1512 1532
1513 #ifdef PDUMP 1533 #ifdef PDUMP
1514 #include "dumper.h" 1534 #include "dumper.h"
1515 #define DUMPEDP(adr) ((((char *) (adr)) < pdump_end) && \ 1535 #define DUMPEDP(adr) ((((Rawbyte *) (adr)) < pdump_end) && \
1516 (((char *) (adr)) >= pdump_start)) 1536 (((Rawbyte *) (adr)) >= pdump_start))
1517 #else 1537 #else
1518 #define DUMPEDP(adr) 0 1538 #define DUMPEDP(adr) 0
1519 #endif 1539 #endif
1520 1540
1521 #define OBJECT_DUMPED_P(obj) DUMPEDP (XPNTR (obj)) 1541 #define OBJECT_DUMPED_P(obj) DUMPEDP (XPNTR (obj))
1532 EMACS_INT lispdesc_indirect_count_1 (EMACS_INT code, 1552 EMACS_INT lispdesc_indirect_count_1 (EMACS_INT code,
1533 const struct memory_description *idesc, 1553 const struct memory_description *idesc,
1534 const void *idata); 1554 const void *idata);
1535 const struct sized_memory_description *lispdesc_indirect_description_1 1555 const struct sized_memory_description *lispdesc_indirect_description_1
1536 (const void *obj, const struct sized_memory_description *sdesc); 1556 (const void *obj, const struct sized_memory_description *sdesc);
1537 Bytecount lispdesc_structure_size (const void *obj, 1557 Bytecount lispdesc_block_size_1 (const void *obj, Bytecount size,
1538 const struct sized_memory_description * 1558 const struct memory_description *desc);
1539 sdesc); 1559
1560 DECLARE_INLINE_HEADER (
1561 Bytecount lispdesc_block_size (const void *obj,
1562 const struct sized_memory_description *sdesc))
1563 {
1564 return lispdesc_block_size_1 (obj, sdesc->size, sdesc->description);
1565 }
1540 1566
1541 DECLARE_INLINE_HEADER ( 1567 DECLARE_INLINE_HEADER (
1542 EMACS_INT 1568 EMACS_INT
1543 lispdesc_indirect_count (EMACS_INT code, 1569 lispdesc_indirect_count (EMACS_INT code,
1544 const struct memory_description *idesc, 1570 const struct memory_description *idesc,