XEmacs 21.2.20 "Yoko".
[chise/xemacs-chise.git.1] / man / internals / internals.texi
1 \input texinfo  @c -*-texinfo-*-
2 @c %**start of header
3 @setfilename ../../info/internals.info
4 @settitle XEmacs Internals Manual
5 @c %**end of header
6
7 @ifinfo
8 @dircategory XEmacs Editor
9 @direntry
10 * Internals: (internals).       XEmacs Internals Manual.
11 @end direntry
12
13 Copyright @copyright{} 1992 - 1996 Ben Wing.
14 Copyright @copyright{} 1996, 1997 Sun Microsystems.
15 Copyright @copyright{} 1994 - 1998 Free Software Foundation.
16 Copyright @copyright{} 1994, 1995 Board of Trustees, University of Illinois.
17
18
19 Permission is granted to make and distribute verbatim copies of this
20 manual provided the copyright notice and this permission notice are
21 preserved on all copies.
22
23 @ignore
24 Permission is granted to process this file through TeX and print the
25 results, provided the printed document carries copying permission notice
26 identical to this one except for the removal of this paragraph (this
27 paragraph not being relevant to the printed manual).
28
29 @end ignore
30 Permission is granted to copy and distribute modified versions of this
31 manual under the conditions for verbatim copying, provided that the
32 entire resulting derived work is distributed under the terms of a
33 permission notice identical to this one.
34
35 Permission is granted to copy and distribute translations of this manual
36 into another language, under the above conditions for modified versions,
37 except that this permission notice may be stated in a translation
38 approved by the Foundation.
39
40 Permission is granted to copy and distribute modified versions of this
41 manual under the conditions for verbatim copying, provided also that the
42 section entitled ``GNU General Public License'' is included exactly as
43 in the original, and provided that the entire resulting derived work is
44 distributed under the terms of a permission notice identical to this
45 one.
46
47 Permission is granted to copy and distribute translations of this manual
48 into another language, under the above conditions for modified versions,
49 except that the section entitled ``GNU General Public License'' may be
50 included in a translation approved by the Free Software Foundation
51 instead of in the original English.
52 @end ifinfo
53
54 @c Combine indices.
55 @synindex cp fn
56 @syncodeindex vr fn
57 @syncodeindex ky fn
58 @syncodeindex pg fn
59 @syncodeindex tp fn
60
61 @setchapternewpage odd
62 @finalout
63
64 @titlepage
65 @title XEmacs Internals Manual
66 @subtitle Version 1.3, August 1999
67
68 @author Ben Wing
69 @author Martin Buchholz
70 @author Hrvoje Niksic
71 @author Matthias Neubauer
72 @page
73 @vskip 0pt plus 1fill
74
75 @noindent
76 Copyright @copyright{} 1992 - 1996 Ben Wing. @*
77 Copyright @copyright{} 1996, 1997 Sun Microsystems, Inc. @*
78 Copyright @copyright{} 1994 - 1998 Free Software Foundation. @*
79 Copyright @copyright{} 1994, 1995 Board of Trustees, University of Illinois.
80
81 @sp 2
82 Version 1.3 @*
83 August 1999.@*
84
85 Permission is granted to make and distribute verbatim copies of this
86 manual provided the copyright notice and this permission notice are
87 preserved on all copies.
88
89 Permission is granted to copy and distribute modified versions of this
90 manual under the conditions for verbatim copying, provided also that the
91 section entitled ``GNU General Public License'' is included
92 exactly as in the original, and provided that the entire resulting
93 derived work is distributed under the terms of a permission notice
94 identical to this one.
95
96 Permission is granted to copy and distribute translations of this manual
97 into another language, under the above conditions for modified versions,
98 except that the section entitled ``GNU General Public License'' may be
99 included in a translation approved by the Free Software Foundation
100 instead of in the original English.
101 @end titlepage
102 @page
103
104 @node Top, A History of Emacs, (dir), (dir)
105
106 @ifinfo
107 This Info file contains v1.0 of the XEmacs Internals Manual.
108 @end ifinfo
109
110 @menu
111 * A History of Emacs::          Times, dates, important events.
112 * XEmacs From the Outside::     A broad conceptual overview.
113 * The Lisp Language::           An overview.
114 * XEmacs From the Perspective of Building::
115 * XEmacs From the Inside::
116 * The XEmacs Object System (Abstractly Speaking)::
117 * How Lisp Objects Are Represented in C::
118 * Rules When Writing New C Code::
119 * A Summary of the Various XEmacs Modules::
120 * Allocation of Objects in XEmacs Lisp::
121 * Events and the Event Loop::
122 * Evaluation; Stack Frames; Bindings::
123 * Symbols and Variables::
124 * Buffers and Textual Representation::
125 * MULE Character Sets and Encodings::
126 * The Lisp Reader and Compiler::
127 * Lstreams::
128 * Consoles; Devices; Frames; Windows::
129 * The Redisplay Mechanism::
130 * Extents::
131 * Faces::
132 * Glyphs::
133 * Specifiers::
134 * Menus::
135 * Subprocesses::
136 * Interface to X Windows::
137 * Index::                   Index including concepts, functions, variables,
138                               and other terms.
139
140       --- The Detailed Node Listing ---
141
142 Here are other nodes that are inferiors of those already listed,
143 mentioned here so you can get to them in one step:
144
145 A History of Emacs
146
147 * Through Version 18::          Unification prevails.
148 * Lucid Emacs::                 One version 19 Emacs.
149 * GNU Emacs 19::                The other version 19 Emacs.
150 * XEmacs::                      The continuation of Lucid Emacs.
151
152 Rules When Writing New C Code
153
154 * General Coding Rules::
155 * Writing Lisp Primitives::
156 * Adding Global Lisp Variables::
157 * Techniques for XEmacs Developers::
158
159 A Summary of the Various XEmacs Modules
160
161 * Low-Level Modules::
162 * Basic Lisp Modules::
163 * Modules for Standard Editing Operations::
164 * Editor-Level Control Flow Modules::
165 * Modules for the Basic Displayable Lisp Objects::
166 * Modules for other Display-Related Lisp Objects::
167 * Modules for the Redisplay Mechanism::
168 * Modules for Interfacing with the File System::
169 * Modules for Other Aspects of the Lisp Interpreter and Object System::
170 * Modules for Interfacing with the Operating System::
171 * Modules for Interfacing with X Windows::
172 * Modules for Internationalization::
173
174 Allocation of Objects in XEmacs Lisp
175
176 * Introduction to Allocation::
177 * Garbage Collection::
178 * GCPROing::
179 * Garbage Collection - Step by Step::
180 * Integers and Characters::
181 * Allocation from Frob Blocks::
182 * lrecords::
183 * Low-level allocation::
184 * Pure Space::
185 * Cons::
186 * Vector::
187 * Bit Vector::
188 * Symbol::
189 * Marker::
190 * String::
191 * Compiled Function::
192
193 Events and the Event Loop
194
195 * Introduction to Events::
196 * Main Loop::
197 * Specifics of the Event Gathering Mechanism::
198 * Specifics About the Emacs Event::
199 * The Event Stream Callback Routines::
200 * Other Event Loop Functions::
201 * Converting Events::
202 * Dispatching Events; The Command Builder::
203
204 Evaluation; Stack Frames; Bindings
205
206 * Evaluation::
207 * Dynamic Binding; The specbinding Stack; Unwind-Protects::
208 * Simple Special Forms::
209 * Catch and Throw::
210
211 Symbols and Variables
212
213 * Introduction to Symbols::
214 * Obarrays::
215 * Symbol Values::
216
217 Buffers and Textual Representation
218
219 * Introduction to Buffers::     A buffer holds a block of text such as a file.
220 * The Text in a Buffer::        Representation of the text in a buffer.
221 * Buffer Lists::                Keeping track of all buffers.
222 * Markers and Extents::         Tagging locations within a buffer.
223 * Bufbytes and Emchars::        Representation of individual characters.
224 * The Buffer Object::           The Lisp object corresponding to a buffer.
225
226 MULE Character Sets and Encodings
227
228 * Character Sets::
229 * Encodings::
230 * Internal Mule Encodings::
231
232 Encodings
233
234 * Japanese EUC (Extended Unix Code)::
235 * JIS7::
236
237 Internal Mule Encodings
238
239 * Internal String Encoding::
240 * Internal Character Encoding::
241
242 The Lisp Reader and Compiler
243
244 Lstreams
245
246 Consoles; Devices; Frames; Windows
247
248 * Introduction to Consoles; Devices; Frames; Windows::
249 * Point::
250 * Window Hierarchy::
251
252 The Redisplay Mechanism
253
254 * Critical Redisplay Sections::
255 * Line Start Cache::
256
257 Extents
258
259 * Introduction to Extents::     Extents are ranges over text, with properties.
260 * Extent Ordering::             How extents are ordered internally.
261 * Format of the Extent Info::   The extent information in a buffer or string.
262 * Zero-Length Extents::         A weird special case.
263 * Mathematics of Extent Ordering::      A rigorous foundation.
264 * Extent Fragments::            Cached information useful for redisplay.
265
266 Faces
267
268 Glyphs
269
270 Specifiers
271
272 Menus
273
274 Subprocesses
275
276 Interface to X Windows
277
278 @end menu
279
280 @node A History of Emacs, XEmacs From the Outside, Top, Top
281 @chapter A History of Emacs
282 @cindex history of Emacs
283 @cindex Hackers (Steven Levy)
284 @cindex Levy, Steven
285 @cindex ITS (Incompatible Timesharing System)
286 @cindex Stallman, Richard
287 @cindex RMS
288 @cindex MIT
289 @cindex TECO
290 @cindex FSF
291 @cindex Free Software Foundation
292
293   XEmacs is a powerful, customizable text editor and development
294 environment.  It began as Lucid Emacs, which was in turn derived from
295 GNU Emacs, a program written by Richard Stallman of the Free Software
296 Foundation.  GNU Emacs dates back to the 1970's, and was modelled
297 after a package called ``Emacs'', written in 1976, that was a set of
298 macros on top of TECO, an old, old text editor written at MIT on the
299 DEC PDP 10 under one of the earliest time-sharing operating systems,
300 ITS (Incompatible Timesharing System). (ITS dates back well before
301 Unix.) ITS, TECO, and Emacs were products of a group of people at MIT
302 who called themselves ``hackers'', who shared an idealistic belief
303 system about the free exchange of information and were fanatical in
304 their devotion to and time spent with computers. (The hacker
305 subculture dates back to the late 1950's at MIT and is described in
306 detail in Steven Levy's book @cite{Hackers}.  This book also includes
307 a lot of information about Stallman himself and the development of
308 Lisp, a programming language developed at MIT that underlies Emacs.)
309
310 @menu
311 * Through Version 18::          Unification prevails.
312 * Lucid Emacs::                 One version 19 Emacs.
313 * GNU Emacs 19::                The other version 19 Emacs.
314 * GNU Emacs 20::                The other version 20 Emacs.
315 * XEmacs::                      The continuation of Lucid Emacs.
316 @end menu
317
318 @node Through Version 18
319 @section Through Version 18
320 @cindex Gosling, James
321 @cindex Great Usenet Renaming
322
323   Although the history of the early versions of GNU Emacs is unclear,
324 the history is well-known from the middle of 1985.  A time line is:
325
326 @itemize @bullet
327 @item
328 GNU Emacs version 15 (15.34) was released sometime in 1984 or 1985 and
329 shared some code with a version of Emacs written by James Gosling (the
330 same James Gosling who later created the Java language).
331 @item
332 GNU Emacs version 16 (first released version was 16.56) was released on
333 July 15, 1985.  All Gosling code was removed due to potential copyright
334 problems with the code.
335 @item
336 version 16.57: released on September 16, 1985.
337 @item
338 versions 16.58, 16.59: released on September 17, 1985.
339 @item
340 version 16.60: released on September 19, 1985.  These later version 16's
341 incorporated patches from the net, esp. for getting Emacs to work under
342 System V.
343 @item
344 version 17.36 (first official v17 release) released on December 20,
345 1985.  Included a TeX-able user manual.  First official unpatched
346 version that worked on vanilla System V machines.
347 @item
348 version 17.43 (second official v17 release) released on January 25,
349 1986.
350 @item
351 version 17.45 released on January 30, 1986.
352 @item
353 version 17.46 released on February 4, 1986.
354 @item
355 version 17.48 released on February 10, 1986.
356 @item
357 version 17.49 released on February 12, 1986.
358 @item
359 version 17.55 released on March 18, 1986.
360 @item
361 version 17.57 released on March 27, 1986.
362 @item
363 version 17.58 released on April 4, 1986.
364 @item
365 version 17.61 released on April 12, 1986.
366 @item
367 version 17.63 released on May 7, 1986.
368 @item
369 version 17.64 released on May 12, 1986.
370 @item
371 version 18.24 (a beta version) released on October 2, 1986.
372 @item
373 version 18.30 (a beta version) released on November 15, 1986.
374 @item
375 version 18.31 (a beta version) released on November 23, 1986.
376 @item
377 version 18.32 (a beta version) released on December 7, 1986.
378 @item
379 version 18.33 (a beta version) released on December 12, 1986.
380 @item
381 version 18.35 (a beta version) released on January 5, 1987.
382 @item
383 version 18.36 (a beta version) released on January 21, 1987.
384 @item
385 January 27, 1987: The Great Usenet Renaming.  net.emacs is now
386 comp.emacs.
387 @item
388 version 18.37 (a beta version) released on February 12, 1987.
389 @item
390 version 18.38 (a beta version) released on March 3, 1987.
391 @item
392 version 18.39 (a beta version) released on March 14, 1987.
393 @item
394 version 18.40 (a beta version) released on March 18, 1987.
395 @item
396 version 18.41 (the first ``official'' release) released on March 22,
397 1987.
398 @item
399 version 18.45 released on June 2, 1987.
400 @item
401 version 18.46 released on June 9, 1987.
402 @item
403 version 18.47 released on June 18, 1987.
404 @item
405 version 18.48 released on September 3, 1987.
406 @item
407 version 18.49 released on September 18, 1987.
408 @item
409 version 18.50 released on February 13, 1988.
410 @item
411 version 18.51 released on May 7, 1988.
412 @item
413 version 18.52 released on September 1, 1988.
414 @item
415 version 18.53 released on February 24, 1989.
416 @item
417 version 18.54 released on April 26, 1989.
418 @item
419 version 18.55 released on August 23, 1989.  This is the earliest version
420 that is still available by FTP.
421 @item
422 version 18.56 released on January 17, 1991.
423 @item
424 version 18.57 released late January, 1991.
425 @item
426 version 18.58 released ?????.
427 @item
428 version 18.59 released October 31, 1992.
429 @end itemize
430
431 @node Lucid Emacs
432 @section Lucid Emacs
433 @cindex Lucid Emacs
434 @cindex Lucid Inc.
435 @cindex Energize
436 @cindex Epoch
437
438   Lucid Emacs was developed by the (now-defunct) Lucid Inc., a maker of
439 C++ and Lisp development environments.  It began when Lucid decided they
440 wanted to use Emacs as the editor and cornerstone of their C++
441 development environment (called ``Energize'').  They needed many features
442 that were not available in the existing version of GNU Emacs (version
443 18.5something), in particular good and integrated support for GUI
444 elements such as mouse support, multiple fonts, multiple window-system
445 windows, etc.  A branch of GNU Emacs called Epoch, written at the
446 University of Illinois, existed that supplied many of these features;
447 however, Lucid needed more than what existed in Epoch.  At the time, the
448 Free Software Foundation was working on version 19 of Emacs (this was
449 sometime around 1991), which was planned to have similar features, and
450 so Lucid decided to work with the Free Software Foundation.  Their plan
451 was to add features that they needed, and coordinate with the FSF so
452 that the features would get included back into Emacs version 19.
453
454   Delays in the release of version 19 occurred, however (resulting in it
455 finally being released more than a year after what was initially
456 planned), and Lucid encountered unexpected technical resistance in
457 getting their changes merged back into version 19, so they decided to
458 release their own version of Emacs, which became Lucid Emacs 19.0.
459
460 @cindex Zawinski, Jamie
461 @cindex Sexton, Harlan
462 @cindex Benson, Eric
463 @cindex Devin, Matthieu
464   The initial authors of Lucid Emacs were Matthieu Devin, Harlan Sexton,
465 and Eric Benson, and the work was later taken over by Jamie Zawinski,
466 who became ``Mr. Lucid Emacs'' for many releases.
467
468   A time line for Lucid Emacs/XEmacs is
469
470 @itemize @bullet
471 @item
472 version 19.0 shipped with Energize 1.0, April 1992.
473 @item
474 version 19.1 released June 4, 1992.
475 @item
476 version 19.2 released June 19, 1992.
477 @item
478 version 19.3 released September 9, 1992.
479 @item
480 version 19.4 released January 21, 1993.
481 @item
482 version 19.5 was a repackaging of 19.4 with a few bug fixes and
483 shipped with Energize 2.0.  Never released to the net.
484 @item
485 version 19.6 released April 9, 1993.
486 @item
487 version 19.7 was a repackaging of 19.6 with a few bug fixes and
488 shipped with Energize 2.1.  Never released to the net.
489 @item
490 version 19.8 released September 6, 1993.
491 @item
492 version 19.9 released January 12, 1994.
493 @item
494 version 19.10 released May 27, 1994.
495 @item
496 version 19.11 (first XEmacs) released September 13, 1994.
497 @item
498 version 19.12 released June 23, 1995.
499 @item
500 version 19.13 released September 1, 1995.
501 @item
502 version 19.14 released June 23, 1996.
503 @item
504 version 20.0 released February 9, 1997.
505 @item
506 version 19.15 released March 28, 1997.
507 @item
508 version 20.1 (not released to the net) April 15, 1997.
509 @item
510 version 20.2 released May 16, 1997.
511 @item
512 version 19.16 released October 31, 1997.
513 @item
514 version 20.3 (the first stable version of XEmacs 20.x) released November 30,
515 1997.
516 version 20.4 released February 28, 1998.
517 @end itemize
518
519 @node GNU Emacs 19
520 @section GNU Emacs 19
521 @cindex GNU Emacs 19
522 @cindex FSF Emacs
523
524   About a year after the initial release of Lucid Emacs, the FSF
525 released a beta of their version of Emacs 19 (referred to here as ``GNU
526 Emacs'').  By this time, the current version of Lucid Emacs was
527 19.6. (Strangely, the first released beta from the FSF was GNU Emacs
528 19.7.) A time line for GNU Emacs version 19 is
529
530 @itemize @bullet
531 @item
532 version 19.8 (beta) released May 27, 1993.
533 @item
534 version 19.9 (beta) released May 27, 1993.
535 @item
536 version 19.10 (beta) released May 30, 1993.
537 @item
538 version 19.11 (beta) released June 1, 1993.
539 @item
540 version 19.12 (beta) released June 2, 1993.
541 @item
542 version 19.13 (beta) released June 8, 1993.
543 @item
544 version 19.14 (beta) released June 17, 1993.
545 @item
546 version 19.15 (beta) released June 19, 1993.
547 @item
548 version 19.16 (beta) released July 6, 1993.
549 @item
550 version 19.17 (beta) released late July, 1993.
551 @item
552 version 19.18 (beta) released August 9, 1993.
553 @item
554 version 19.19 (beta) released August 15, 1993.
555 @item
556 version 19.20 (beta) released November 17, 1993.
557 @item
558 version 19.21 (beta) released November 17, 1993.
559 @item
560 version 19.22 (beta) released November 28, 1993.
561 @item
562 version 19.23 (beta) released May 17, 1994.
563 @item
564 version 19.24 (beta) released May 16, 1994.
565 @item
566 version 19.25 (beta) released June 3, 1994.
567 @item
568 version 19.26 (beta) released September 11, 1994.
569 @item
570 version 19.27 (beta) released September 14, 1994.
571 @item
572 version 19.28 (first ``official'' release) released November 1, 1994.
573 @item
574 version 19.29 released June 21, 1995.
575 @item
576 version 19.30 released November 24, 1995.
577 @item
578 version 19.31 released May 25, 1996.
579 @item
580 version 19.32 released July 31, 1996.
581 @item
582 version 19.33 released August 11, 1996.
583 @item
584 version 19.34 released August 21, 1996.
585 @item
586 version 19.34b released September 6, 1996.
587 @end itemize
588
589 @cindex Mlynarik, Richard
590   In some ways, GNU Emacs 19 was better than Lucid Emacs; in some ways,
591 worse.  Lucid soon began incorporating features from GNU Emacs 19 into
592 Lucid Emacs; the work was mostly done by Richard Mlynarik, who had been
593 working on and using GNU Emacs for a long time (back as far as version
594 16 or 17).
595
596 @node GNU Emacs 20
597 @section GNU Emacs 20
598 @cindex GNU Emacs 20
599 @cindex FSF Emacs
600
601 On February 2, 1997 work began on GNU Emacs to integrate Mule.  The first
602 release was made in September of that year.
603
604 A timeline for Emacs 20 is
605
606 @itemize @bullet
607 @item
608 version 20.1 released September 17, 1997.
609 @item
610 version 20.2 released September 20, 1997.
611 @item
612 version 20.3 released August 19, 1998.
613 @end itemize
614
615 @node XEmacs
616 @section XEmacs
617 @cindex XEmacs
618
619 @cindex Sun Microsystems
620 @cindex University of Illinois
621 @cindex Illinois, University of
622 @cindex SPARCWorks
623 @cindex Andreessen, Marc
624 @cindex Baur, Steve
625 @cindex Buchholz, Martin
626 @cindex Kaplan, Simon
627 @cindex Wing, Ben
628 @cindex Thompson, Chuck
629 @cindex Win-Emacs
630 @cindex Epoch
631 @cindex Amdahl Corporation
632   Around the time that Lucid was developing Energize, Sun Microsystems
633 was developing their own development environment (called ``SPARCWorks'')
634 and also decided to use Emacs.  They joined forces with the Epoch team
635 at the University of Illinois and later with Lucid.  The maintainer of
636 the last-released version of Epoch was Marc Andreessen, but he dropped
637 out and the Epoch project, headed by Simon Kaplan, lured Chuck Thompson
638 away from a system administration job to become the primary Lucid Emacs
639 author for Epoch and Sun.  Chuck's area of specialty became the
640 redisplay engine (he replaced the old Lucid Emacs redisplay engine with
641 a ported version from Epoch and then later rewrote it from scratch).
642 Sun also hired Ben Wing (the author of Win-Emacs, a port of Lucid Emacs
643 to Microsoft Windows 3.1) in 1993, for what was initially a one-month
644 contract to fix some event problems but later became a many-year
645 involvement, punctuated by a six-month contract with Amdahl Corporation.
646
647 @cindex rename to XEmacs
648   In 1994, Sun and Lucid agreed to rename Lucid Emacs to XEmacs (a name
649 not favorable to either company); the first release called XEmacs was
650 version 19.11.  In June 1994, Lucid folded and Jamie quit to work for
651 the newly formed Mosaic Communications Corp., later Netscape
652 Communications Corp. (co-founded by the same Marc Andreessen, who had
653 quit his Epoch job to work on a graphical browser for the World Wide
654 Web).  Chuck then become the primary maintainer of XEmacs, and put out
655 versions 19.11 through 19.14 in conjunction with Ben.  For 19.12 and
656 19.13, Chuck added the new redisplay and many other display improvements
657 and Ben added MULE support (support for Asian and other languages) and
658 redesigned most of the internal Lisp subsystems to better support the
659 MULE work and the various other features being added to XEmacs.  After
660 19.14 Chuck retired as primary maintainer and Steve Baur stepped in.
661
662 @cindex MULE merged XEmacs appears
663   Soon after 19.13 was released, work began in earnest on the MULE
664 internationalization code and the source tree was divided into two
665 development paths.  The MULE version was initially called 19.20, but was
666 soon renamed to 20.0.  In 1996 Martin Buchholz of Sun Microsystems took
667 over the care and feeding of it and worked on it in parallel with the
668 19.14 development that was occurring at the same time.  After much work
669 by Martin, it was decided to release 20.0 ahead of 19.15 in February
670 1997.  The source tree remained divided until 20.2 when the version 19
671 source was finally retired at version 19.16.
672
673 @cindex Baur, Steve
674 @cindex Buchholz, Martin
675 @cindex Jones, Kyle
676 @cindex Niksic, Hrvoje
677 @cindex XEmacs goes it alone
678   In 1997, Sun finally dropped all pretense of support for XEmacs and
679 Martin Buchholz left the company in November.  Since then, and mostly
680 for the previous year, because Steve Baur was never paid to work on
681 XEmacs, XEmacs has existed solely on the contributions of volunteers
682 from the Free Software Community.  Starting from 1997, Hrvoje Niksic and
683 Kyle Jones have figured prominently in XEmacs development.
684
685 @cindex merging attempts
686   Many attempts have been made to merge XEmacs and GNU Emacs, but they
687 have consistently failed.
688
689   A more detailed history is contained in the XEmacs About page.
690
691 @node XEmacs From the Outside, The Lisp Language, A History of Emacs, Top
692 @chapter XEmacs From the Outside
693 @cindex read-eval-print
694
695   XEmacs appears to the outside world as an editor, but it is really a
696 Lisp environment.  At its heart is a Lisp interpreter; it also
697 ``happens'' to contain many specialized object types (e.g. buffers,
698 windows, frames, events) that are useful for implementing an editor.
699 Some of these objects (in particular windows and frames) have
700 displayable representations, and XEmacs provides a function
701 @code{redisplay()} that ensures that the display of all such objects
702 matches their internal state.  Most of the time, a standard Lisp
703 environment is in a @dfn{read-eval-print} loop -- i.e. ``read some Lisp
704 code, execute it, and print the results''.  XEmacs has a similar loop:
705
706 @itemize @bullet
707 @item
708 read an event
709 @item
710 dispatch the event (i.e. ``do it'')
711 @item
712 redisplay
713 @end itemize
714
715   Reading an event is done using the Lisp function @code{next-event},
716 which waits for something to happen (typically, the user presses a key
717 or moves the mouse) and returns an event object describing this.
718 Dispatching an event is done using the Lisp function
719 @code{dispatch-event}, which looks up the event in a keymap object (a
720 particular kind of object that associates an event with a Lisp function)
721 and calls that function.  The function ``does'' what the user has
722 requested by changing the state of particular frame objects, buffer
723 objects, etc.  Finally, @code{redisplay()} is called, which updates the
724 display to reflect those changes just made.  Thus is an ``editor'' born.
725
726 @cindex bridge, playing
727 @cindex taxes, doing
728 @cindex pi, calculating
729   Note that you do not have to use XEmacs as an editor; you could just
730 as well make it do your taxes, compute pi, play bridge, etc.  You'd just
731 have to write functions to do those operations in Lisp.
732
733 @node The Lisp Language, XEmacs From the Perspective of Building, XEmacs From the Outside, Top
734 @chapter The Lisp Language
735 @cindex Lisp vs. C
736 @cindex C vs. Lisp
737 @cindex Lisp vs. Java
738 @cindex Java vs. Lisp
739 @cindex dynamic scoping
740 @cindex scoping, dynamic
741 @cindex dynamic types
742 @cindex types, dynamic
743 @cindex Java
744 @cindex Common Lisp
745 @cindex Gosling, James
746
747   Lisp is a general-purpose language that is higher-level than C and in
748 many ways more powerful than C.  Powerful dialects of Lisp such as
749 Common Lisp are probably much better languages for writing very large
750 applications than is C. (Unfortunately, for many non-technical
751 reasons C and its successor C++ have become the dominant languages for
752 application development.  These languages are both inadequate for
753 extremely large applications, which is evidenced by the fact that newer,
754 larger programs are becoming ever harder to write and are requiring ever
755 more programmers despite great increases in C development environments;
756 and by the fact that, although hardware speeds and reliability have been
757 growing at an exponential rate, most software is still generally
758 considered to be slow and buggy.)
759
760   The new Java language holds promise as a better general-purpose
761 development language than C.  Java has many features in common with
762 Lisp that are not shared by C (this is not a coincidence, since
763 Java was designed by James Gosling, a former Lisp hacker).  This
764 will be discussed more later.
765
766 For those used to C, here is a summary of the basic differences between
767 C and Lisp:
768
769 @enumerate
770 @item
771 Lisp has an extremely regular syntax.  Every function, expression,
772 and control statement is written in the form
773
774 @example
775    (@var{func} @var{arg1} @var{arg2} ...)
776 @end example
777
778 This is as opposed to C, which writes functions as
779
780 @example
781    func(@var{arg1}, @var{arg2}, ...)
782 @end example
783
784 but writes expressions involving operators as (e.g.)
785
786 @example
787    @var{arg1} + @var{arg2}
788 @end example
789
790 and writes control statements as (e.g.)
791
792 @example
793    while (@var{expr}) @{ @var{statement1}; @var{statement2}; ... @}
794 @end example
795
796 Lisp equivalents of the latter two would be
797
798 @example
799    (+ @var{arg1} @var{arg2} ...)
800 @end example
801
802 and
803
804 @example
805    (while @var{expr} @var{statement1} @var{statement2} ...)
806 @end example
807
808 @item
809 Lisp is a safe language.  Assuming there are no bugs in the Lisp
810 interpreter/compiler, it is impossible to write a program that ``core
811 dumps'' or otherwise causes the machine to execute an illegal
812 instruction.  This is very different from C, where perhaps the most
813 common outcome of a bug is exactly such a crash.  A corollary of this is that
814 the C operation of casting a pointer is impossible (and unnecessary) in
815 Lisp, and that it is impossible to access memory outside the bounds of
816 an array.
817
818 @item
819 Programs and data are written in the same form.  The
820 parenthesis-enclosing form described above for statements is the same
821 form used for the most common data type in Lisp, the list.  Thus, it is
822 possible to represent any Lisp program using Lisp data types, and for
823 one program to construct Lisp statements and then dynamically
824 @dfn{evaluate} them, or cause them to execute.
825
826 @item
827 All objects are @dfn{dynamically typed}.  This means that part of every
828 object is an indication of what type it is.  A Lisp program can
829 manipulate an object without knowing what type it is, and can query an
830 object to determine its type.  This means that, correspondingly,
831 variables and function parameters can hold objects of any type and are
832 not normally declared as being of any particular type.  This is opposed
833 to the @dfn{static typing} of C, where variables can hold exactly one
834 type of object and must be declared as such, and objects do not contain
835 an indication of their type because it's implicit in the variables they
836 are stored in.  It is possible in C to have a variable hold different
837 types of objects (e.g. through the use of @code{void *} pointers or
838 variable-argument functions), but the type information must then be
839 passed explicitly in some other fashion, leading to additional program
840 complexity.
841
842 @item
843 Allocated memory is automatically reclaimed when it is no longer in use.
844 This operation is called @dfn{garbage collection} and involves looking
845 through all variables to see what memory is being pointed to, and
846 reclaiming any memory that is not pointed to and is thus
847 ``inaccessible'' and out of use.  This is as opposed to C, in which
848 allocated memory must be explicitly reclaimed using @code{free()}.  If
849 you simply drop all pointers to memory without freeing it, it becomes
850 ``leaked'' memory that still takes up space.  Over a long period of
851 time, this can cause your program to grow and grow until it runs out of
852 memory.
853
854 @item
855 Lisp has built-in facilities for handling errors and exceptions.  In C,
856 when an error occurs, usually either the program exits entirely or the
857 routine in which the error occurs returns a value indicating this.  If
858 an error occurs in a deeply-nested routine, then every routine currently
859 called must unwind itself normally and return an error value back up to
860 the next routine.  This means that every routine must explicitly check
861 for an error in all the routines it calls; if it does not do so,
862 unexpected and often random behavior results.  This is an extremely
863 common source of bugs in C programs.  An alternative would be to do a
864 non-local exit using @code{longjmp()}, but that is often very dangerous
865 because the routines that were exited past had no opportunity to clean
866 up after themselves and may leave things in an inconsistent state,
867 causing a crash shortly afterwards.
868
869 Lisp provides mechanisms to make such non-local exits safe.  When an
870 error occurs, a routine simply signals that an error of a particular
871 class has occurred, and a non-local exit takes place.  Any routine can
872 trap errors occurring in routines it calls by registering an error
873 handler for some or all classes of errors. (If no handler is registered,
874 a default handler, generally installed by the top-level event loop, is
875 executed; this prints out the error and continues.) Routines can also
876 specify cleanup code (called an @dfn{unwind-protect}) that will be
877 called when control exits from a block of code, no matter how that exit
878 occurs -- i.e. even if a function deeply nested below it causes a
879 non-local exit back to the top level.
880
881 Note that this facility has appeared in some recent vintages of C, in
882 particular Visual C++ and other PC compilers written for the Microsoft
883 Win32 API.
884
885 @item
886 In Emacs Lisp, local variables are @dfn{dynamically scoped}.  This means
887 that if you declare a local variable in a particular function, and then
888 call another function, that subfunction can ``see'' the local variable
889 you declared.  This is actually considered a bug in Emacs Lisp and in
890 all other early dialects of Lisp, and was corrected in Common Lisp. (In
891 Common Lisp, you can still declare dynamically scoped variables if you
892 want to -- they are sometimes useful -- but variables by default are
893 @dfn{lexically scoped} as in C.)
894 @end enumerate
895
896 For those familiar with Lisp, Emacs Lisp is modelled after MacLisp, an
897 early dialect of Lisp developed at MIT (no relation to the Macintosh
898 computer).  There is a Common Lisp compatibility package available for
899 Emacs that provides many of the features of Common Lisp.
900
901 The Java language is derived in many ways from C, and shares a similar
902 syntax, but has the following features in common with Lisp (and different
903 from C):
904
905 @enumerate
906 @item
907 Java is a safe language, like Lisp.
908 @item
909 Java provides garbage collection, like Lisp.
910 @item
911 Java has built-in facilities for handling errors and exceptions, like
912 Lisp.
913 @item
914 Java has a type system that combines the best advantages of both static
915 and dynamic typing.  Objects (except very simple types) are explicitly
916 marked with their type, as in dynamic typing; but there is a hierarchy
917 of types and functions are declared to accept only certain types, thus
918 providing the increased compile-time error-checking of static typing.
919 @end enumerate
920
921 The Java language also has some negative attributes:
922
923 @enumerate
924 @item
925 Java uses the edit/compile/run model of software development.  This
926 makes it hard to use interactively.  For example, to use Java like
927 @code{bc} it is necessary to write a special purpose, albeit tiny,
928 application.  In Emacs Lisp, a calculator comes built-in without any
929 effort - one can always just type an expression in the @code{*scratch*}
930 buffer.
931 @item
932 Java tries too hard to enforce, not merely enable, portability, making
933 ordinary access to standard OS facilities painful.  Java has an
934 @dfn{agenda}.  I think this is why @code{chdir} is not part of standard
935 Java, which is inexcusable.
936 @end enumerate
937
938 Unfortunately, there is no perfect language.  Static typing allows a
939 compiler to catch programmer errors and produce more efficient code, but
940 makes programming more tedious and less fun.  For the forseeable future,
941 an Ideal Editing and Programming Environment (and that is what XEmacs
942 aspires to) will be programmable in multiple languages: high level ones
943 like Lisp for user customization and prototyping, and lower level ones
944 for infrastructure and industrial strength applications.  If I had my
945 way, XEmacs would be friendly towards the Python, Scheme, C++, ML,
946 etc... communities.  But there are serious technical difficulties to
947 achieving that goal.
948
949 The word @dfn{application} in the previous paragraph was used
950 intentionally.  XEmacs implements an API for programs written in Lisp
951 that makes it a full-fledged application platform, very much like an OS
952 inside the real OS.
953
954 @node XEmacs From the Perspective of Building, XEmacs From the Inside, The Lisp Language, Top
955 @chapter XEmacs From the Perspective of Building
956
957 The heart of XEmacs is the Lisp environment, which is written in C.
958 This is contained in the @file{src/} subdirectory.  Underneath
959 @file{src/} are two subdirectories of header files: @file{s/} (header
960 files for particular operating systems) and @file{m/} (header files for
961 particular machine types).  In practice the distinction between the two
962 types of header files is blurred.  These header files define or undefine
963 certain preprocessor constants and macros to indicate particular
964 characteristics of the associated machine or operating system.  As part
965 of the configure process, one @file{s/} file and one @file{m/} file is
966 identified for the particular environment in which XEmacs is being
967 built.
968
969 XEmacs also contains a great deal of Lisp code.  This implements the
970 operations that make XEmacs useful as an editor as well as just a Lisp
971 environment, and also contains many add-on packages that allow XEmacs to
972 browse directories, act as a mail and Usenet news reader, compile Lisp
973 code, etc.  There is actually more Lisp code than C code associated with
974 XEmacs, but much of the Lisp code is peripheral to the actual operation
975 of the editor.  The Lisp code all lies in subdirectories underneath the
976 @file{lisp/} directory.
977
978 The @file{lwlib/} directory contains C code that implements a
979 generalized interface onto different X widget toolkits and also
980 implements some widgets of its own that behave like Motif widgets but
981 are faster, free, and in some cases more powerful.  The code in this
982 directory compiles into a library and is mostly independent from XEmacs.
983
984 The @file{etc/} directory contains various data files associated with
985 XEmacs.  Some of them are actually read by XEmacs at startup; others
986 merely contain useful information of various sorts.
987
988 The @file{lib-src/} directory contains C code for various auxiliary
989 programs that are used in connection with XEmacs.  Some of them are used
990 during the build process; others are used to perform certain functions
991 that cannot conveniently be placed in the XEmacs executable (e.g. the
992 @file{movemail} program for fetching mail out of @file{/var/spool/mail},
993 which must be setgid to @file{mail} on many systems; and the
994 @file{gnuclient} program, which allows an external script to communicate
995 with a running XEmacs process).
996
997 The @file{man/} directory contains the sources for the XEmacs
998 documentation.  It is mostly in a form called Texinfo, which can be
999 converted into either a printed document (by passing it through @TeX{})
1000 or into on-line documentation called @dfn{info files}.
1001
1002 The @file{info/} directory contains the results of formatting the XEmacs
1003 documentation as @dfn{info files}, for on-line use.  These files are
1004 used when you enter the Info system using @kbd{C-h i} or through the
1005 Help menu.
1006
1007 The @file{dynodump/} directory contains auxiliary code used to build
1008 XEmacs on Solaris platforms.
1009
1010 The other directories contain various miscellaneous code and information
1011 that is not normally used or needed.
1012
1013 The first step of building involves running the @file{configure} program
1014 and passing it various parameters to specify any optional features you
1015 want and compiler arguments and such, as described in the @file{INSTALL}
1016 file.  This determines what the build environment is, chooses the
1017 appropriate @file{s/} and @file{m/} file, and runs a series of tests to
1018 determine many details about your environment, such as which library
1019 functions are available and exactly how they work.  The reason for
1020 running these tests is that it allows XEmacs to be compiled on a much
1021 wider variety of platforms than those that the XEmacs developers happen
1022 to be familiar with, including various sorts of hybrid platforms.  This
1023 is especially important now that many operating systems give you a great
1024 deal of control over exactly what features you want installed, and allow
1025 for easy upgrading of parts of a system without upgrading the rest.  It
1026 would be impossible to pre-determine and pre-specify the information for
1027 all possible configurations.
1028
1029 In fact, the @file{s/} and @file{m/} files are basically @emph{evil},
1030 since they contain unmaintainable platform-specific hard-coded
1031 information.  XEmacs has been moving in the direction of having all
1032 system-specific information be determined dynamically by
1033 @file{configure}.  Perhaps someday we can @code{rm -rf src/s src/m}.
1034
1035 When configure is done running, it generates @file{Makefile}s and
1036 @file{GNUmakefile}s and the file @file{src/config.h} (which describes
1037 the features of your system) from template files.  You then run
1038 @file{make}, which compiles the auxiliary code and programs in
1039 @file{lib-src/} and @file{lwlib/} and the main XEmacs executable in
1040 @file{src/}.  The result of compiling and linking is an executable
1041 called @file{temacs}, which is @emph{not} the final XEmacs executable.
1042 @file{temacs} by itself is not intended to function as an editor or even
1043 display any windows on the screen, and if you simply run it, it will
1044 exit immediately.  The @file{Makefile} runs @file{temacs} with certain
1045 options that cause it to initialize itself, read in a number of basic
1046 Lisp files, and then dump itself out into a new executable called
1047 @file{xemacs}.  This new executable has been pre-initialized and
1048 contains pre-digested Lisp code that is necessary for the editor to
1049 function (this includes most basic editing functions,
1050 e.g. @code{kill-line}, that can be defined in terms of other Lisp
1051 primitives; some initialization code that is called when certain
1052 objects, such as frames, are created; and all of the standard
1053 keybindings and code for the actions they result in).  This executable,
1054 @file{xemacs}, is the executable that you run to use the XEmacs editor.
1055
1056 Although @file{temacs} is not intended to be run as an editor, it can,
1057 by using the incantation @code{temacs -batch -l loadup.el run-temacs}.
1058 This is useful when the dumping procedure described above is broken, or
1059 when using certain program debugging tools such as Purify.  These tools
1060 get mighty confused by the tricks played by the XEmacs build process,
1061 such as allocation memory in one process, and freeing it in the next.
1062
1063 @node XEmacs From the Inside, The XEmacs Object System (Abstractly Speaking), XEmacs From the Perspective of Building, Top
1064 @chapter XEmacs From the Inside
1065
1066 Internally, XEmacs is quite complex, and can be very confusing.  To
1067 simplify things, it can be useful to think of XEmacs as containing an
1068 event loop that ``drives'' everything, and a number of other subsystems,
1069 such as a Lisp engine and a redisplay mechanism.  Each of these other
1070 subsystems exists simultaneously in XEmacs, and each has a certain
1071 state.  The flow of control continually passes in and out of these
1072 different subsystems in the course of normal operation of the editor.
1073
1074 It is important to keep in mind that, most of the time, the editor is
1075 ``driven'' by the event loop.  Except during initialization and batch
1076 mode, all subsystems are entered directly or indirectly through the
1077 event loop, and ultimately, control exits out of all subsystems back up
1078 to the event loop.  This cycle of entering a subsystem, exiting back out
1079 to the event loop, and starting another iteration of the event loop
1080 occurs once each keystroke, mouse motion, etc.
1081
1082 If you're trying to understand a particular subsystem (other than the
1083 event loop), think of it as a ``daemon'' process or ``servant'' that is
1084 responsible for one particular aspect of a larger system, and
1085 periodically receives commands or environment changes that cause it to
1086 do something.  Ultimately, these commands and environment changes are
1087 always triggered by the event loop.  For example:
1088
1089 @itemize @bullet
1090 @item
1091 The window and frame mechanism is responsible for keeping track of what
1092 windows and frames exist, what buffers are in them, etc.  It is
1093 periodically given commands (usually from the user) to make a change to
1094 the current window/frame state: i.e. create a new frame, delete a
1095 window, etc.
1096
1097 @item
1098 The buffer mechanism is responsible for keeping track of what buffers
1099 exist and what text is in them.  It is periodically given commands
1100 (usually from the user) to insert or delete text, create a buffer, etc.
1101 When it receives a text-change command, it notifies the redisplay
1102 mechanism.
1103
1104 @item
1105 The redisplay mechanism is responsible for making sure that windows and
1106 frames are displayed correctly.  It is periodically told (by the event
1107 loop) to actually ``do its job'', i.e. snoop around and see what the
1108 current state of the environment (mostly of the currently-existing
1109 windows, frames, and buffers) is, and make sure that that state matches
1110 what's actually displayed.  It keeps lots and lots of information around
1111 (such as what is actually being displayed currently, and what the
1112 environment was last time it checked) so that it can minimize the work
1113 it has to do.  It is also helped along in that whenever a relevant
1114 change to the environment occurs, the redisplay mechanism is told about
1115 this, so it has a pretty good idea of where it has to look to find
1116 possible changes and doesn't have to look everywhere.
1117
1118 @item
1119 The Lisp engine is responsible for executing the Lisp code in which most
1120 user commands are written.  It is entered through a call to @code{eval}
1121 or @code{funcall}, which occurs as a result of dispatching an event from
1122 the event loop.  The functions it calls issue commands to the buffer
1123 mechanism, the window/frame subsystem, etc.
1124
1125 @item
1126 The Lisp allocation subsystem is responsible for keeping track of Lisp
1127 objects.  It is given commands from the Lisp engine to allocate objects,
1128 garbage collect, etc.
1129 @end itemize
1130
1131 etc.
1132
1133   The important idea here is that there are a number of independent
1134 subsystems each with its own responsibility and persistent state, just
1135 like different employees in a company, and each subsystem is
1136 periodically given commands from other subsystems.  Commands can flow
1137 from any one subsystem to any other, but there is usually some sort of
1138 hierarchy, with all commands originating from the event subsystem.
1139
1140   XEmacs is entered in @code{main()}, which is in @file{emacs.c}.  When
1141 this is called the first time (in a properly-invoked @file{temacs}), it
1142 does the following:
1143
1144 @enumerate
1145 @item
1146 It does some very basic environment initializations, such as determining
1147 where it and its directories (e.g. @file{lisp/} and @file{etc/}) reside
1148 and setting up signal handlers.
1149 @item
1150 It initializes the entire Lisp interpreter.
1151 @item
1152 It sets the initial values of many built-in variables (including many
1153 variables that are visible to Lisp programs), such as the global keymap
1154 object and the built-in faces (a face is an object that describes the
1155 display characteristics of text).  This involves creating Lisp objects
1156 and thus is dependent on step (2).
1157 @item
1158 It performs various other initializations that are relevant to the
1159 particular environment it is running in, such as retrieving environment
1160 variables, determining the current date and the user who is running the
1161 program, examining its standard input, creating any necessary file
1162 descriptors, etc.
1163 @item
1164 At this point, the C initialization is complete.  A Lisp program that
1165 was specified on the command line (usually @file{loadup.el}) is called
1166 (temacs is normally invoked as @code{temacs -batch -l loadup.el dump}).
1167 @file{loadup.el} loads all of the other Lisp files that are needed for
1168 the operation of the editor, calls the @code{dump-emacs} function to
1169 write out @file{xemacs}, and then kills the temacs process.
1170 @end enumerate
1171
1172   When @file{xemacs} is then run, it only redoes steps (1) and (4)
1173 above; all variables already contain the values they were set to when
1174 the executable was dumped, and all memory that was allocated with
1175 @code{malloc()} is still around. (XEmacs knows whether it is being run
1176 as @file{xemacs} or @file{temacs} because it sets the global variable
1177 @code{initialized} to 1 after step (4) above.) At this point,
1178 @file{xemacs} calls a Lisp function to do any further initialization,
1179 which includes parsing the command-line (the C code can only do limited
1180 command-line parsing, which includes looking for the @samp{-batch} and
1181 @samp{-l} flags and a few other flags that it needs to know about before
1182 initialization is complete), creating the first frame (or @dfn{window}
1183 in standard window-system parlance), running the user's init file
1184 (usually the file @file{.emacs} in the user's home directory), etc.  The
1185 function to do this is usually called @code{normal-top-level};
1186 @file{loadup.el} tells the C code about this function by setting its
1187 name as the value of the Lisp variable @code{top-level}.
1188
1189   When the Lisp initialization code is done, the C code enters the event
1190 loop, and stays there for the duration of the XEmacs process.  The code
1191 for the event loop is contained in @file{keyboard.c}, and is called
1192 @code{Fcommand_loop_1()}.  Note that this event loop could very well be
1193 written in Lisp, and in fact a Lisp version exists; but apparently,
1194 doing this makes XEmacs run noticeably slower.
1195
1196   Notice how much of the initialization is done in Lisp, not in C.
1197 In general, XEmacs tries to move as much code as is possible
1198 into Lisp.  Code that remains in C is code that implements the
1199 Lisp interpreter itself, or code that needs to be very fast, or
1200 code that needs to do system calls or other such stuff that
1201 needs to be done in C, or code that needs to have access to
1202 ``forbidden'' structures. (One conscious aspect of the design of
1203 Lisp under XEmacs is a clean separation between the external
1204 interface to a Lisp object's functionality and its internal
1205 implementation.  Part of this design is that Lisp programs
1206 are forbidden from accessing the contents of the object other
1207 than through using a standard API.  In this respect, XEmacs Lisp
1208 is similar to modern Lisp dialects but differs from GNU Emacs,
1209 which tends to expose the implementation and allow Lisp
1210 programs to look at it directly.  The major advantage of
1211 hiding the implementation is that it allows the implementation
1212 to be redesigned without affecting any Lisp programs, including
1213 those that might want to be ``clever'' by looking directly at
1214 the object's contents and possibly manipulating them.)
1215
1216   Moving code into Lisp makes the code easier to debug and maintain and
1217 makes it much easier for people who are not XEmacs developers to
1218 customize XEmacs, because they can make a change with much less chance
1219 of obscure and unwanted interactions occurring than if they were to
1220 change the C code.
1221
1222 @node The XEmacs Object System (Abstractly Speaking), How Lisp Objects Are Represented in C, XEmacs From the Inside, Top
1223 @chapter The XEmacs Object System (Abstractly Speaking)
1224
1225   At the heart of the Lisp interpreter is its management of objects.
1226 XEmacs Lisp contains many built-in objects, some of which are
1227 simple and others of which can be very complex; and some of which
1228 are very common, and others of which are rarely used or are only
1229 used internally. (Since the Lisp allocation system, with its
1230 automatic reclamation of unused storage, is so much more convenient
1231 than @code{malloc()} and @code{free()}, the C code makes extensive use of it
1232 in its internal operations.)
1233
1234   The basic Lisp objects are
1235
1236 @table @code
1237 @item integer
1238 28 or 31 bits of precision, or 60 or 63 bits on 64-bit machines; the
1239 reason for this is described below when the internal Lisp object
1240 representation is described.
1241 @item float
1242 Same precision as a double in C.
1243 @item cons
1244 A simple container for two Lisp objects, used to implement lists and
1245 most other data structures in Lisp.
1246 @item char
1247 An object representing a single character of text; chars behave like
1248 integers in many ways but are logically considered text rather than
1249 numbers and have a different read syntax. (the read syntax for a char
1250 contains the char itself or some textual encoding of it -- for example,
1251 a Japanese Kanji character might be encoded as @samp{^[$(B#&^[(B} using the
1252 ISO-2022 encoding standard -- rather than the numerical representation
1253 of the char; this way, if the mapping between chars and integers
1254 changes, which is quite possible for Kanji characters and other extended
1255 characters, the same character will still be created.  Note that some
1256 primitives confuse chars and integers.  The worst culprit is @code{eq},
1257 which makes a special exception and considers a char to be @code{eq} to
1258 its integer equivalent, even though in no other case are objects of two
1259 different types @code{eq}.  The reason for this monstrosity is
1260 compatibility with existing code; the separation of char from integer
1261 came fairly recently.)
1262 @item symbol
1263 An object that contains Lisp objects and is referred to by name;
1264 symbols are used to implement variables and named functions
1265 and to provide the equivalent of preprocessor constants in C.
1266 @item vector
1267 A one-dimensional array of Lisp objects providing constant-time access
1268 to any of the objects; access to an arbitrary object in a vector is
1269 faster than for lists, but the operations that can be done on a vector
1270 are more limited.
1271 @item string
1272 Self-explanatory; behaves much like a vector of chars
1273 but has a different read syntax and is stored and manipulated
1274 more compactly.
1275 @item bit-vector
1276 A vector of bits; similar to a string in spirit.
1277 @item compiled-function
1278 An object containing compiled Lisp code, known as @dfn{byte code}.
1279 @item subr
1280 A Lisp primitive, i.e. a Lisp-callable function implemented in C.
1281 @end table
1282
1283 @cindex closure
1284 Note that there is no basic ``function'' type, as in more powerful
1285 versions of Lisp (where it's called a @dfn{closure}).  XEmacs Lisp does
1286 not provide the closure semantics implemented by Common Lisp and Scheme.
1287 The guts of a function in XEmacs Lisp are represented in one of four
1288 ways: a symbol specifying another function (when one function is an
1289 alias for another), a list (whose first element must be the symbol
1290 @code{lambda}) containing the function's source code, a
1291 compiled-function object, or a subr object. (In other words, given a
1292 symbol specifying the name of a function, calling @code{symbol-function}
1293 to retrieve the contents of the symbol's function cell will return one
1294 of these types of objects.)
1295
1296 XEmacs Lisp also contains numerous specialized objects used to implement
1297 the editor:
1298
1299 @table @code
1300 @item buffer
1301 Stores text like a string, but is optimized for insertion and deletion
1302 and has certain other properties that can be set.
1303 @item frame
1304 An object with various properties whose displayable representation is a
1305 @dfn{window} in window-system parlance.
1306 @item window
1307 A section of a frame that displays the contents of a buffer;
1308 often called a @dfn{pane} in window-system parlance.
1309 @item window-configuration
1310 An object that represents a saved configuration of windows in a frame.
1311 @item device
1312 An object representing a screen on which frames can be displayed;
1313 equivalent to a @dfn{display} in the X Window System and a @dfn{TTY} in
1314 character mode.
1315 @item face
1316 An object specifying the appearance of text or graphics; it has
1317 properties such as font, foreground color, and background color.
1318 @item marker
1319 An object that refers to a particular position in a buffer and moves
1320 around as text is inserted and deleted to stay in the same relative
1321 position to the text around it.
1322 @item extent
1323 Similar to a marker but covers a range of text in a buffer; can also
1324 specify properties of the text, such as a face in which the text is to
1325 be displayed, whether the text is invisible or unmodifiable, etc.
1326 @item event
1327 Generated by calling @code{next-event} and contains information
1328 describing a particular event happening in the system, such as the user
1329 pressing a key or a process terminating.
1330 @item keymap
1331 An object that maps from events (described using lists, vectors, and
1332 symbols rather than with an event object because the mapping is for
1333 classes of events, rather than individual events) to functions to
1334 execute or other events to recursively look up; the functions are
1335 described by name, using a symbol, or using lists to specify the
1336 function's code.
1337 @item glyph
1338 An object that describes the appearance of an image (e.g.  pixmap) on
1339 the screen; glyphs can be attached to the beginning or end of extents
1340 and in some future version of XEmacs will be able to be inserted
1341 directly into a buffer.
1342 @item process
1343 An object that describes a connection to an externally-running process.
1344 @end table
1345
1346   There are some other, less-commonly-encountered general objects:
1347
1348 @table @code
1349 @item hash-table
1350 An object that maps from an arbitrary Lisp object to another arbitrary
1351 Lisp object, using hashing for fast lookup.
1352 @item obarray
1353 A limited form of hash-table that maps from strings to symbols; obarrays
1354 are used to look up a symbol given its name and are not actually their
1355 own object type but are kludgily represented using vectors with hidden
1356 fields (this representation derives from GNU Emacs).
1357 @item specifier
1358 A complex object used to specify the value of a display property; a
1359 default value is given and different values can be specified for
1360 particular frames, buffers, windows, devices, or classes of device.
1361 @item char-table
1362 An object that maps from chars or classes of chars to arbitrary Lisp
1363 objects; internally char tables use a complex nested-vector
1364 representation that is optimized to the way characters are represented
1365 as integers.
1366 @item range-table
1367 An object that maps from ranges of integers to arbitrary Lisp objects.
1368 @end table
1369
1370   And some strange special-purpose objects:
1371
1372 @table @code
1373 @item charset
1374 @itemx coding-system
1375 Objects used when MULE, or multi-lingual/Asian-language, support is
1376 enabled.
1377 @item color-instance
1378 @itemx font-instance
1379 @itemx image-instance
1380 An object that encapsulates a window-system resource; instances are
1381 mostly used internally but are exposed on the Lisp level for cleanness
1382 of the specifier model and because it's occasionally useful for Lisp
1383 program to create or query the properties of instances.
1384 @item subwindow
1385 An object that encapsulate a @dfn{subwindow} resource, i.e. a
1386 window-system child window that is drawn into by an external process;
1387 this object should be integrated into the glyph system but isn't yet,
1388 and may change form when this is done.
1389 @item tooltalk-message
1390 @itemx tooltalk-pattern
1391 Objects that represent resources used in the ToolTalk interprocess
1392 communication protocol.
1393 @item toolbar-button
1394 An object used in conjunction with the toolbar.
1395 @end table
1396
1397   And objects that are only used internally:
1398
1399 @table @code
1400 @item opaque
1401 A generic object for encapsulating arbitrary memory; this allows you the
1402 generality of @code{malloc()} and the convenience of the Lisp object
1403 system.
1404 @item lstream
1405 A buffering I/O stream, used to provide a unified interface to anything
1406 that can accept output or provide input, such as a file descriptor, a
1407 stdio stream, a chunk of memory, a Lisp buffer, a Lisp string, etc.;
1408 it's a Lisp object to make its memory management more convenient.
1409 @item char-table-entry
1410 Subsidiary objects in the internal char-table representation.
1411 @item extent-auxiliary
1412 @itemx menubar-data
1413 @itemx toolbar-data
1414 Various special-purpose objects that are basically just used to
1415 encapsulate memory for particular subsystems, similar to the more
1416 general ``opaque'' object.
1417 @item symbol-value-forward
1418 @itemx symbol-value-buffer-local
1419 @itemx symbol-value-varalias
1420 @itemx symbol-value-lisp-magic
1421 Special internal-only objects that are placed in the value cell of a
1422 symbol to indicate that there is something special with this variable --
1423 e.g. it has no value, it mirrors another variable, or it mirrors some C
1424 variable; there is really only one kind of object, called a
1425 @dfn{symbol-value-magic}, but it is sort-of halfway kludged into
1426 semi-different object types.
1427 @end table
1428
1429 @cindex permanent objects
1430 @cindex temporary objects
1431   Some types of objects are @dfn{permanent}, meaning that once created,
1432 they do not disappear until explicitly destroyed, using a function such
1433 as @code{delete-buffer}, @code{delete-window}, @code{delete-frame}, etc.
1434 Others will disappear once they are not longer used, through the garbage
1435 collection mechanism.  Buffers, frames, windows, devices, and processes
1436 are among the objects that are permanent.  Note that some objects can go
1437 both ways: Faces can be created either way; extents are normally
1438 permanent, but detached extents (extents not referring to any text, as
1439 happens to some extents when the text they are referring to is deleted)
1440 are temporary.  Note that some permanent objects, such as faces and
1441 coding systems, cannot be deleted.  Note also that windows are unique in
1442 that they can be @emph{undeleted} after having previously been
1443 deleted. (This happens as a result of restoring a window configuration.)
1444
1445 @cindex read syntax
1446   Note that many types of objects have a @dfn{read syntax}, i.e. a way of
1447 specifying an object of that type in Lisp code.  When you load a Lisp
1448 file, or type in code to be evaluated, what really happens is that the
1449 function @code{read} is called, which reads some text and creates an object
1450 based on the syntax of that text; then @code{eval} is called, which
1451 possibly does something special; then this loop repeats until there's
1452 no more text to read. (@code{eval} only actually does something special
1453 with symbols, which causes the symbol's value to be returned,
1454 similar to referencing a variable; and with conses [i.e. lists],
1455 which cause a function invocation.  All other values are returned
1456 unchanged.)
1457
1458   The read syntax
1459
1460 @example
1461 17297
1462 @end example
1463
1464 converts to an integer whose value is 17297.
1465
1466 @example
1467 1.983e-4
1468 @end example
1469
1470 converts to a float whose value is 1.983e-4, or .0001983.
1471
1472 @example
1473 ?b
1474 @end example
1475
1476 converts to a char that represents the lowercase letter b.
1477
1478 @example
1479 ?^[$(B#&^[(B
1480 @end example
1481
1482 (where @samp{^[} actually is an @samp{ESC} character) converts to a
1483 particular Kanji character when using an ISO2022-based coding system for
1484 input. (To decode this goo: @samp{ESC} begins an escape sequence;
1485 @samp{ESC $ (} is a class of escape sequences meaning ``switch to a
1486 94x94 character set''; @samp{ESC $ ( B} means ``switch to Japanese
1487 Kanji''; @samp{#} and @samp{&} collectively index into a 94-by-94 array
1488 of characters [subtract 33 from the ASCII value of each character to get
1489 the corresponding index]; @samp{ESC (} is a class of escape sequences
1490 meaning ``switch to a 94 character set''; @samp{ESC (B} means ``switch
1491 to US ASCII''.  It is a coincidence that the letter @samp{B} is used to
1492 denote both Japanese Kanji and US ASCII.  If the first @samp{B} were
1493 replaced with an @samp{A}, you'd be requesting a Chinese Hanzi character
1494 from the GB2312 character set.)
1495
1496 @example
1497 "foobar"
1498 @end example
1499
1500 converts to a string.
1501
1502 @example
1503 foobar
1504 @end example
1505
1506 converts to a symbol whose name is @code{"foobar"}.  This is done by
1507 looking up the string equivalent in the global variable
1508 @code{obarray}, whose contents should be an obarray.  If no symbol
1509 is found, a new symbol with the name @code{"foobar"} is automatically
1510 created and added to @code{obarray}; this process is called
1511 @dfn{interning} the symbol.
1512 @cindex interning
1513
1514 @example
1515 (foo . bar)
1516 @end example
1517
1518 converts to a cons cell containing the symbols @code{foo} and @code{bar}.
1519
1520 @example
1521 (1 a 2.5)
1522 @end example
1523
1524 converts to a three-element list containing the specified objects
1525 (note that a list is actually a set of nested conses; see the
1526 XEmacs Lisp Reference).
1527
1528 @example
1529 [1 a 2.5]
1530 @end example
1531
1532 converts to a three-element vector containing the specified objects.
1533
1534 @example
1535 #[... ... ... ...]
1536 @end example
1537
1538 converts to a compiled-function object (the actual contents are not
1539 shown since they are not relevant here; look at a file that ends with
1540 @file{.elc} for examples).
1541
1542 @example
1543 #*01110110
1544 @end example
1545
1546 converts to a bit-vector.
1547
1548 @example
1549 #s(hash-table ... ...)
1550 @end example
1551
1552 converts to a hash table (the actual contents are not shown).
1553
1554 @example
1555 #s(range-table ... ...)
1556 @end example
1557
1558 converts to a range table (the actual contents are not shown).
1559
1560 @example
1561 #s(char-table ... ...)
1562 @end example
1563
1564 converts to a char table (the actual contents are not shown).
1565
1566 Note that the @code{#s()} syntax is the general syntax for structures,
1567 which are not really implemented in XEmacs Lisp but should be.
1568
1569 When an object is printed out (using @code{print} or a related
1570 function), the read syntax is used, so that the same object can be read
1571 in again.
1572
1573 The other objects do not have read syntaxes, usually because it does not
1574 really make sense to create them in this fashion (i.e.  processes, where
1575 it doesn't make sense to have a subprocess created as a side effect of
1576 reading some Lisp code), or because they can't be created at all
1577 (e.g. subrs).  Permanent objects, as a rule, do not have a read syntax;
1578 nor do most complex objects, which contain too much state to be easily
1579 initialized through a read syntax.
1580
1581 @node How Lisp Objects Are Represented in C, Rules When Writing New C Code, The XEmacs Object System (Abstractly Speaking), Top
1582 @chapter How Lisp Objects Are Represented in C
1583
1584 Lisp objects are represented in C using a 32-bit or 64-bit machine word
1585 (depending on the processor; i.e. DEC Alphas use 64-bit Lisp objects and
1586 most other processors use 32-bit Lisp objects).  The representation
1587 stuffs a pointer together with a tag, as follows:
1588
1589 @example
1590  [ 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 ]
1591  [ 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 ]
1592
1593    <---> ^ <------------------------------------------------------>
1594     tag  |       a pointer to a structure, or an integer
1595          |
1596        mark bit
1597 @end example
1598
1599 The tag describes the type of the Lisp object.  For integers and chars,
1600 the lower 28 bits contain the value of the integer or char; for all
1601 others, the lower 28 bits contain a pointer.  The mark bit is used
1602 during garbage-collection, and is always 0 when garbage collection is
1603 not happening. (The way that garbage collection works, basically, is that it
1604 loops over all places where Lisp objects could exist -- this includes
1605 all global variables in C that contain Lisp objects [including
1606 @code{Vobarray}, the C equivalent of @code{obarray}; through this, all
1607 Lisp variables will get marked], plus various other places -- and
1608 recursively scans through the Lisp objects, marking each object it finds
1609 by setting the mark bit.  Then it goes through the lists of all objects
1610 allocated, freeing the ones that are not marked and turning off the mark
1611 bit of the ones that are marked.)
1612
1613 Lisp objects use the typedef @code{Lisp_Object}, but the actual C type
1614 used for the Lisp object can vary.  It can be either a simple type
1615 (@code{long} on the DEC Alpha, @code{int} on other machines) or a
1616 structure whose fields are bit fields that line up properly (actually, a
1617 union of structures is used).  Generally the simple integral type is
1618 preferable because it ensures that the compiler will actually use a
1619 machine word to represent the object (some compilers will use more
1620 general and less efficient code for unions and structs even if they can
1621 fit in a machine word).  The union type, however, has the advantage of
1622 stricter type checking (if you accidentally pass an integer where a Lisp
1623 object is desired, you get a compile error), and it makes it easier to
1624 decode Lisp objects when debugging.  The choice of which type to use is
1625 determined by the preprocessor constant @code{USE_UNION_TYPE} which is
1626 defined via the @code{--use-union-type} option to @code{configure}.
1627
1628 @cindex record type
1629
1630 Note that there are only eight types that the tag can represent, but
1631 many more actual types than this.  This is handled by having one of the
1632 tag types specify a meta-type called a @dfn{record}; for all such
1633 objects, the first four bytes of the pointed-to structure indicate what
1634 the actual type is.
1635
1636 Note also that having 28 bits for pointers and integers restricts a lot
1637 of things to 256 megabytes of memory. (Basically, enough pointers and
1638 indices and whatnot get stuffed into Lisp objects that the total amount
1639 of memory used by XEmacs can't grow above 256 megabytes.  In older
1640 versions of XEmacs and GNU Emacs, the tag was 5 bits wide, allowing for
1641 32 types, which was more than the actual number of types that existed at
1642 the time, and no ``record'' type was necessary.  However, this limited
1643 the editor to 64 megabytes total, which some users who edited large
1644 files might conceivably exceed.)
1645
1646 Also, note that there is an implicit assumption here that all pointers
1647 are low enough that the top bits are all zero and can just be chopped
1648 off.  On standard machines that allocate memory from the bottom up (and
1649 give each process its own address space), this works fine.  Some
1650 machines, however, put the data space somewhere else in memory
1651 (e.g. beginning at 0x80000000).  Those machines cope by defining
1652 @code{DATA_SEG_BITS} in the corresponding @file{m/} or @file{s/} file to
1653 the proper mask.  Then, pointers retrieved from Lisp objects are
1654 automatically OR'ed with this value prior to being used.
1655
1656 A corollary of the previous paragraph is that @strong{(pointers to)
1657 stack-allocated structures cannot be put into Lisp objects}.  The stack
1658 is generally located near the top of memory; if you put such a pointer
1659 into a Lisp object, it will get its top bits chopped off, and you will
1660 lose.
1661
1662 Actually, there's an alternative representation of a @code{Lisp_Object},
1663 invented by Kyle Jones, that is used when the
1664 @code{--use-minimal-tagbits} option to @code{configure} is used.  In
1665 this case the 2 lower bits are used for the tag bits.  This
1666 representation assumes that pointers to structs are always aligned to
1667 multiples of 4, so the lower 2 bits are always zero.
1668
1669 @example
1670  [ 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 ]
1671  [ 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 ]
1672
1673    <---------------------------------------------------------> <->
1674             a pointer to a structure, or an integer            tag
1675 @end example
1676
1677 A tag of 00 is used for all pointer object types, a tag of 10 is used
1678 for characters, and the other two tags 01 and 11 are joined together to
1679 form the integer object type.  The markbit is moved to part of the
1680 structure being pointed at (integers and chars do not need to be marked,
1681 since no memory is allocated).  This representation has these
1682 advantages:
1683
1684 @enumerate
1685 @item
1686 31 bits can be used for Lisp Integers.
1687 @item
1688 @emph{Any} pointer can be represented directly, and no bit masking
1689 operations are necessary.
1690 @end enumerate
1691
1692 The disadvantages are:
1693
1694 @enumerate
1695 @item
1696 An extra level of indirection is needed when accessing the object types
1697 that were not record types.  So checking whether a Lisp object is a cons
1698 cell becomes a slower operation.
1699 @item
1700 Mark bits can no longer be stored directly in Lisp objects, so another
1701 place for them must be found.  This means that a cons cell requires more
1702 memory than merely room for 2 lisp objects, leading to extra memory use.
1703 @end enumerate
1704
1705 Various macros are used to construct Lisp objects and extract the
1706 components.  Macros of the form @code{XINT()}, @code{XCHAR()},
1707 @code{XSTRING()}, @code{XSYMBOL()}, etc. mask out the pointer/integer
1708 field and cast it to the appropriate type.  All of the macros that
1709 construct pointers will @code{OR} with @code{DATA_SEG_BITS} if
1710 necessary.  @code{XINT()} needs to be a bit tricky so that negative
1711 numbers are properly sign-extended: Usually it does this by shifting the
1712 number four bits to the left and then four bits to the right.  This
1713 assumes that the right-shift operator does an arithmetic shift (i.e. it
1714 leaves the most-significant bit as-is rather than shifting in a zero, so
1715 that it mimics a divide-by-two even for negative numbers).  Not all
1716 machines/compilers do this, and on the ones that don't, a more
1717 complicated definition is selected by defining
1718 @code{EXPLICIT_SIGN_EXTEND}.
1719
1720 Note that when @code{ERROR_CHECK_TYPECHECK} is defined, the extractor
1721 macros become more complicated -- they check the tag bits and/or the
1722 type field in the first four bytes of a record type to ensure that the
1723 object is really of the correct type.  This is great for catching places
1724 where an incorrect type is being dereferenced -- this typically results
1725 in a pointer being dereferenced as the wrong type of structure, with
1726 unpredictable (and sometimes not easily traceable) results.
1727
1728 There are similar @code{XSET@var{TYPE}()} macros that construct a Lisp
1729 object.  These macros are of the form @code{XSET@var{TYPE}
1730 (@var{lvalue}, @var{result})},
1731 i.e. they have to be a statement rather than just used in an expression.
1732 The reason for this is that standard C doesn't let you ``construct'' a
1733 structure (but GCC does).  Granted, this sometimes isn't too convenient;
1734 for the case of integers, at least, you can use the function
1735 @code{make_int()}, which constructs and @emph{returns} an integer
1736 Lisp object.  Note that the @code{XSET@var{TYPE}()} macros are also
1737 affected by @code{ERROR_CHECK_TYPECHECK} and make sure that the
1738 structure is of the right type in the case of record types, where the
1739 type is contained in the structure.
1740
1741 The C programmer is responsible for @strong{guaranteeing} that a
1742 Lisp_Object is is the correct type before using the @code{X@var{TYPE}}
1743 macros.  This is especially important in the case of lists.  Use
1744 @code{XCAR} and @code{XCDR} if a Lisp_Object is certainly a cons cell,
1745 else use @code{Fcar()} and @code{Fcdr()}.  Trust other C code, but not
1746 Lisp code.  On the other hand, if XEmacs has an internal logic error,
1747 it's better to crash immediately, so sprinkle ``unreachable''
1748 @code{abort()}s liberally about the source code.
1749
1750 @node Rules When Writing New C Code, A Summary of the Various XEmacs Modules, How Lisp Objects Are Represented in C, Top
1751 @chapter Rules When Writing New C Code
1752
1753 The XEmacs C Code is extremely complex and intricate, and there are many
1754 rules that are more or less consistently followed throughout the code.
1755 Many of these rules are not obvious, so they are explained here.  It is
1756 of the utmost importance that you follow them.  If you don't, you may
1757 get something that appears to work, but which will crash in odd
1758 situations, often in code far away from where the actual breakage is.
1759
1760 @menu
1761 * General Coding Rules::
1762 * Writing Lisp Primitives::
1763 * Adding Global Lisp Variables::
1764 * Coding for Mule::
1765 * Techniques for XEmacs Developers::
1766 @end menu
1767
1768 @node General Coding Rules
1769 @section General Coding Rules
1770
1771 The C code is actually written in a dialect of C called @dfn{Clean C},
1772 meaning that it can be compiled, mostly warning-free, with either a C or
1773 C++ compiler.  Coding in Clean C has several advantages over plain C.
1774 C++ compilers are more nit-picking, and a number of coding errors have
1775 been found by compiling with C++.  The ability to use both C and C++
1776 tools means that a greater variety of development tools are available to
1777 the developer.
1778
1779 Almost every module contains a @code{syms_of_*()} function and a
1780 @code{vars_of_*()} function.  The former declares any Lisp primitives
1781 you have defined and defines any symbols you will be using.  The latter
1782 declares any global Lisp variables you have added and initializes global
1783 C variables in the module.  For each such function, declare it in
1784 @file{symsinit.h} and make sure it's called in the appropriate place in
1785 @file{emacs.c}.  @strong{Important}: There are stringent requirements on
1786 exactly what can go into these functions.  See the comment in
1787 @file{emacs.c}.  The reason for this is to avoid obscure unwanted
1788 interactions during initialization.  If you don't follow these rules,
1789 you'll be sorry!  If you want to do anything that isn't allowed, create
1790 a @code{complex_vars_of_*()} function for it.  Doing this is tricky,
1791 though: You have to make sure your function is called at the right time
1792 so that all the initialization dependencies work out.
1793
1794 Every module includes @file{<config.h>} (angle brackets so that
1795 @samp{--srcdir} works correctly; @file{config.h} may or may not be in
1796 the same directory as the C sources) and @file{lisp.h}.  @file{config.h}
1797 must always be included before any other header files (including
1798 system header files) to ensure that certain tricks played by various
1799 @file{s/} and @file{m/} files work out correctly.
1800
1801 @strong{All global and static variables that are to be modifiable must
1802 be declared uninitialized.}  This means that you may not use the
1803 ``declare with initializer'' form for these variables, such as @code{int
1804 some_variable = 0;}.  The reason for this has to do with some kludges
1805 done during the dumping process: If possible, the initialized data
1806 segment is re-mapped so that it becomes part of the (unmodifiable) code
1807 segment in the dumped executable.  This allows this memory to be shared
1808 among multiple running XEmacs processes.  XEmacs is careful to place as
1809 much constant data as possible into initialized variables (in
1810 particular, into what's called the @dfn{pure space} -- see below) during
1811 the @file{temacs} phase.
1812
1813 @cindex copy-on-write
1814 @strong{Please note:} This kludge only works on a few systems nowadays,
1815 and is rapidly becoming irrelevant because most modern operating systems
1816 provide @dfn{copy-on-write} semantics.  All data is initially shared
1817 between processes, and a private copy is automatically made (on a
1818 page-by-page basis) when a process first attempts to write to a page of
1819 memory.
1820
1821 Formerly, there was a requirement that static variables not be declared
1822 inside of functions.  This had to do with another hack along the same
1823 vein as what was just described: old USG systems put statically-declared
1824 variables in the initialized data space, so those header files had a
1825 @code{#define static} declaration. (That way, the data-segment remapping
1826 described above could still work.) This fails badly on static variables
1827 inside of functions, which suddenly become automatic variables;
1828 therefore, you weren't supposed to have any of them.  This awful kludge
1829 has been removed in XEmacs because
1830
1831 @enumerate
1832 @item
1833 almost all of the systems that used this kludge ended up having
1834 to disable the data-segment remapping anyway;
1835 @item
1836 the only systems that didn't were extremely outdated ones;
1837 @item
1838 this hack completely messed up inline functions.
1839 @end enumerate
1840
1841 The C source code makes heavy use of C preprocessor macros.  One popular
1842 macro style is:
1843
1844 @example
1845 #define FOO(var, value) do @{           \
1846   Lisp_Object FOO_value = (value);      \
1847   ... /* compute using FOO_value */     \
1848   (var) = bar;                          \
1849 @} while (0)
1850 @end example
1851
1852 The @code{do @{...@} while (0)} is a standard trick to allow FOO to have
1853 statement semantics, so that it can safely be used within an @code{if}
1854 statement in C, for example.  Multiple evaluation is prevented by
1855 copying a supplied argument into a local variable, so that
1856 @code{FOO(var,fun(1))} only calls @code{fun} once.
1857
1858 Lisp lists are popular data structures in the C code as well as in
1859 Elisp.  There are two sets of macros that iterate over lists.
1860 @code{EXTERNAL_LIST_LOOP_@var{n}} should be used when the list has been
1861 supplied by the user, and cannot be trusted to be acyclic and
1862 nil-terminated.  A @code{malformed-list} or @code{circular-list} error
1863 will be generated if the list being iterated over is not entirely
1864 kosher.  @code{LIST_LOOP_@var{n}}, on the other hand, is faster and less
1865 safe, and can be used only on trusted lists.
1866
1867 Related macros are @code{GET_EXTERNAL_LIST_LENGTH} and
1868 @code{GET_LIST_LENGTH}, which calculate the length of a list, and in the
1869 case of @code{GET_EXTERNAL_LIST_LENGTH}, validating the properness of
1870 the list.  The macros @code{EXTERNAL_LIST_LOOP_DELETE_IF} and
1871 @code{LIST_LOOP_DELETE_IF} delete elements from a lisp list satisfying some
1872 predicate.
1873
1874 @node Writing Lisp Primitives
1875 @section Writing Lisp Primitives
1876
1877 Lisp primitives are Lisp functions implemented in C.  The details of
1878 interfacing the C function so that Lisp can call it are handled by a few
1879 C macros.  The only way to really understand how to write new C code is
1880 to read the source, but we can explain some things here.
1881
1882 An example of a special form is the definition of @code{prog1}, from
1883 @file{eval.c}.  (An ordinary function would have the same general
1884 appearance.)
1885
1886 @cindex garbage collection protection
1887 @smallexample
1888 @group
1889 DEFUN ("prog1", Fprog1, 1, UNEVALLED, 0, /*
1890 Similar to `progn', but the value of the first form is returned.
1891 \(prog1 FIRST BODY...): All the arguments are evaluated sequentially.
1892 The value of FIRST is saved during evaluation of the remaining args,
1893 whose values are discarded.
1894 */
1895        (args))
1896 @{
1897   /* This function can GC */
1898   REGISTER Lisp_Object val, form, tail;
1899   struct gcpro gcpro1;
1900
1901   val = Feval (XCAR (args));
1902
1903   GCPRO1 (val);
1904
1905   LIST_LOOP_3 (form, XCDR (args), tail)
1906     Feval (form);
1907
1908   UNGCPRO;
1909   return val;
1910 @}
1911 @end group
1912 @end smallexample
1913
1914   Let's start with a precise explanation of the arguments to the
1915 @code{DEFUN} macro.  Here is a template for them:
1916
1917 @example
1918 @group
1919 DEFUN (@var{lname}, @var{fname}, @var{min_args}, @var{max_args}, @var{interactive}, /*
1920 @var{docstring}
1921 */
1922    (@var{arglist}))
1923 @end group
1924 @end example
1925
1926 @table @var
1927 @item lname
1928 This string is the name of the Lisp symbol to define as the function
1929 name; in the example above, it is @code{"prog1"}.
1930
1931 @item fname
1932 This is the C function name for this function.  This is the name that is
1933 used in C code for calling the function.  The name is, by convention,
1934 @samp{F} prepended to the Lisp name, with all dashes (@samp{-}) in the
1935 Lisp name changed to underscores.  Thus, to call this function from C
1936 code, call @code{Fprog1}.  Remember that the arguments are of type
1937 @code{Lisp_Object}; various macros and functions for creating values of
1938 type @code{Lisp_Object} are declared in the file @file{lisp.h}.
1939
1940 Primitives whose names are special characters (e.g. @code{+} or
1941 @code{<}) are named by spelling out, in some fashion, the special
1942 character: e.g. @code{Fplus()} or @code{Flss()}.  Primitives whose names
1943 begin with normal alphanumeric characters but also contain special
1944 characters are spelled out in some creative way, e.g. @code{let*}
1945 becomes @code{FletX()}.
1946
1947 Each function also has an associated structure that holds the data for
1948 the subr object that represents the function in Lisp.  This structure
1949 conveys the Lisp symbol name to the initialization routine that will
1950 create the symbol and store the subr object as its definition.  The C
1951 variable name of this structure is always @samp{S} prepended to the
1952 @var{fname}.  You hardly ever need to be aware of the existence of this
1953 structure, since @code{DEFUN} plus @code{DEFSUBR} takes care of all the
1954 details.
1955
1956 @item min_args
1957 This is the minimum number of arguments that the function requires.  The
1958 function @code{prog1} allows a minimum of one argument.
1959
1960 @item max_args
1961 This is the maximum number of arguments that the function accepts, if
1962 there is a fixed maximum.  Alternatively, it can be @code{UNEVALLED},
1963 indicating a special form that receives unevaluated arguments, or
1964 @code{MANY}, indicating an unlimited number of evaluated arguments (the
1965 C equivalent of @code{&rest}).  Both @code{UNEVALLED} and @code{MANY}
1966 are macros.  If @var{max_args} is a number, it may not be less than
1967 @var{min_args} and it may not be greater than 8. (If you need to add a
1968 function with more than 8 arguments, use the @code{MANY} form.  Resist
1969 the urge to edit the definition of @code{DEFUN} in @file{lisp.h}.  If
1970 you do it anyways, make sure to also add another clause to the switch
1971 statement in @code{primitive_funcall().})
1972
1973 @item interactive
1974 This is an interactive specification, a string such as might be used as
1975 the argument of @code{interactive} in a Lisp function.  In the case of
1976 @code{prog1}, it is 0 (a null pointer), indicating that @code{prog1}
1977 cannot be called interactively.  A value of @code{""} indicates a
1978 function that should receive no arguments when called interactively.
1979
1980 @item docstring
1981 This is the documentation string.  It is written just like a
1982 documentation string for a function defined in Lisp; in particular, the
1983 first line should be a single sentence.  Note how the documentation
1984 string is enclosed in a comment, none of the documentation is placed on
1985 the same lines as the comment-start and comment-end characters, and the
1986 comment-start characters are on the same line as the interactive
1987 specification.  @file{make-docfile}, which scans the C files for
1988 documentation strings, is very particular about what it looks for, and
1989 will not properly extract the doc string if it's not in this exact format.
1990
1991 In order to make both @file{etags} and @file{make-docfile} happy, make
1992 sure that the @code{DEFUN} line contains the @var{lname} and
1993 @var{fname}, and that the comment-start characters for the doc string
1994 are on the same line as the interactive specification, and put a newline
1995 directly after them (and before the comment-end characters).
1996
1997 @item arglist
1998 This is the comma-separated list of arguments to the C function.  For a
1999 function with a fixed maximum number of arguments, provide a C argument
2000 for each Lisp argument.  In this case, unlike regular C functions, the
2001 types of the arguments are not declared; they are simply always of type
2002 @code{Lisp_Object}.
2003
2004 The names of the C arguments will be used as the names of the arguments
2005 to the Lisp primitive as displayed in its documentation, modulo the same
2006 concerns described above for @code{F...} names (in particular,
2007 underscores in the C arguments become dashes in the Lisp arguments).
2008
2009 There is one additional kludge: A trailing `_' on the C argument is
2010 discarded when forming the Lisp argument.  This allows C language
2011 reserved words (like @code{default}) or global symbols (like
2012 @code{dirname}) to be used as argument names without compiler warnings
2013 or errors.
2014
2015 A Lisp function with @w{@var{max_args} = @code{UNEVALLED}} is a
2016 @w{@dfn{special form}}; its arguments are not evaluated.  Instead it
2017 receives one argument of type @code{Lisp_Object}, a (Lisp) list of the
2018 unevaluated arguments, conventionally named @code{(args)}.
2019
2020 When a Lisp function has no upper limit on the number of arguments,
2021 specify @w{@var{max_args} = @code{MANY}}.  In this case its implementation in
2022 C actually receives exactly two arguments: the number of Lisp arguments
2023 (an @code{int}) and the address of a block containing their values (a
2024 @w{@code{Lisp_Object *}}).  In this case only are the C types specified
2025 in the @var{arglist}: @w{@code{(int nargs, Lisp_Object *args)}}.
2026
2027 @end table
2028
2029 Within the function @code{Fprog1} itself, note the use of the macros
2030 @code{GCPRO1} and @code{UNGCPRO}.  @code{GCPRO1} is used to ``protect''
2031 a variable from garbage collection---to inform the garbage collector
2032 that it must look in that variable and regard the object pointed at by
2033 its contents as an accessible object.  This is necessary whenever you
2034 call @code{Feval} or anything that can directly or indirectly call
2035 @code{Feval} (this includes the @code{QUIT} macro!).  At such a time,
2036 any Lisp object that you intend to refer to again must be protected
2037 somehow.  @code{UNGCPRO} cancels the protection of the variables that
2038 are protected in the current function.  It is necessary to do this
2039 explicitly.
2040
2041 The macro @code{GCPRO1} protects just one local variable.  If you want
2042 to protect two, use @code{GCPRO2} instead; repeating @code{GCPRO1} will
2043 not work.  Macros @code{GCPRO3} and @code{GCPRO4} also exist.
2044
2045 These macros implicitly use local variables such as @code{gcpro1}; you
2046 must declare these explicitly, with type @code{struct gcpro}.  Thus, if
2047 you use @code{GCPRO2}, you must declare @code{gcpro1} and @code{gcpro2}.
2048
2049 @cindex caller-protects (@code{GCPRO} rule)
2050 Note also that the general rule is @dfn{caller-protects}; i.e. you are
2051 only responsible for protecting those Lisp objects that you create.  Any
2052 objects passed to you as arguments should have been protected by whoever
2053 created them, so you don't in general have to protect them.
2054
2055 In particular, the arguments to any Lisp primitive are always
2056 automatically @code{GCPRO}ed, when called ``normally'' from Lisp code or
2057 bytecode.  So only a few Lisp primitives that are called frequently from
2058 C code, such as @code{Fprogn} protect their arguments as a service to
2059 their caller.  You don't need to protect your arguments when writing a
2060 new @code{DEFUN}.
2061
2062 @code{GCPRO}ing is perhaps the trickiest and most error-prone part of
2063 XEmacs coding.  It is @strong{extremely} important that you get this
2064 right and use a great deal of discipline when writing this code.
2065 @xref{GCPROing, ,@code{GCPRO}ing}, for full details on how to do this.
2066
2067 What @code{DEFUN} actually does is declare a global structure of type
2068 @code{Lisp_Subr} whose name begins with capital @samp{SF} and which
2069 contains information about the primitive (e.g. a pointer to the
2070 function, its minimum and maximum allowed arguments, a string describing
2071 its Lisp name); @code{DEFUN} then begins a normal C function declaration
2072 using the @code{F...} name.  The Lisp subr object that is the function
2073 definition of a primitive (i.e. the object in the function slot of the
2074 symbol that names the primitive) actually points to this @samp{SF}
2075 structure; when @code{Feval} encounters a subr, it looks in the
2076 structure to find out how to call the C function.
2077
2078 Defining the C function is not enough to make a Lisp primitive
2079 available; you must also create the Lisp symbol for the primitive (the
2080 symbol is @dfn{interned}; @pxref{Obarrays}) and store a suitable subr
2081 object in its function cell. (If you don't do this, the primitive won't
2082 be seen by Lisp code.) The code looks like this:
2083
2084 @example
2085 DEFSUBR (@var{fname});
2086 @end example
2087
2088 @noindent
2089 Here @var{fname} is the same name you used as the second argument to
2090 @code{DEFUN}.
2091
2092 This call to @code{DEFSUBR} should go in the @code{syms_of_*()} function
2093 at the end of the module.  If no such function exists, create it and
2094 make sure to also declare it in @file{symsinit.h} and call it from the
2095 appropriate spot in @code{main()}.  @xref{General Coding Rules}.
2096
2097 Note that C code cannot call functions by name unless they are defined
2098 in C.  The way to call a function written in Lisp from C is to use
2099 @code{Ffuncall}, which embodies the Lisp function @code{funcall}.  Since
2100 the Lisp function @code{funcall} accepts an unlimited number of
2101 arguments, in C it takes two: the number of Lisp-level arguments, and a
2102 one-dimensional array containing their values.  The first Lisp-level
2103 argument is the Lisp function to call, and the rest are the arguments to
2104 pass to it.  Since @code{Ffuncall} can call the evaluator, you must
2105 protect pointers from garbage collection around the call to
2106 @code{Ffuncall}. (However, @code{Ffuncall} explicitly protects all of
2107 its parameters, so you don't have to protect any pointers passed as
2108 parameters to it.)
2109
2110 The C functions @code{call0}, @code{call1}, @code{call2}, and so on,
2111 provide handy ways to call a Lisp function conveniently with a fixed
2112 number of arguments.  They work by calling @code{Ffuncall}.
2113
2114 @file{eval.c} is a very good file to look through for examples;
2115 @file{lisp.h} contains the definitions for important macros and
2116 functions.
2117
2118 @node Adding Global Lisp Variables
2119 @section Adding Global Lisp Variables
2120
2121 Global variables whose names begin with @samp{Q} are constants whose
2122 value is a symbol of a particular name.  The name of the variable should
2123 be derived from the name of the symbol using the same rules as for Lisp
2124 primitives.  These variables are initialized using a call to
2125 @code{defsymbol()} in the @code{syms_of_*()} function. (This call
2126 interns a symbol, sets the C variable to the resulting Lisp object, and
2127 calls @code{staticpro()} on the C variable to tell the
2128 garbage-collection mechanism about this variable.  What
2129 @code{staticpro()} does is add a pointer to the variable to a large
2130 global array; when garbage-collection happens, all pointers listed in
2131 the array are used as starting points for marking Lisp objects.  This is
2132 important because it's quite possible that the only current reference to
2133 the object is the C variable.  In the case of symbols, the
2134 @code{staticpro()} doesn't matter all that much because the symbol is
2135 contained in @code{obarray}, which is itself @code{staticpro()}ed.
2136 However, it's possible that a naughty user could do something like
2137 uninterning the symbol out of @code{obarray} or even setting
2138 @code{obarray} to a different value [although this is likely to make
2139 XEmacs crash!].)
2140
2141   @strong{Please note:} It is potentially deadly if you declare a
2142 @samp{Q...}  variable in two different modules.  The two calls to
2143 @code{defsymbol()} are no problem, but some linkers will complain about
2144 multiply-defined symbols.  The most insidious aspect of this is that
2145 often the link will succeed anyway, but then the resulting executable
2146 will sometimes crash in obscure ways during certain operations!  To
2147 avoid this problem, declare any symbols with common names (such as
2148 @code{text}) that are not obviously associated with this particular
2149 module in the module @file{general.c}.
2150
2151   Global variables whose names begin with @samp{V} are variables that
2152 contain Lisp objects.  The convention here is that all global variables
2153 of type @code{Lisp_Object} begin with @samp{V}, and all others don't
2154 (including integer and boolean variables that have Lisp
2155 equivalents). Most of the time, these variables have equivalents in
2156 Lisp, but some don't.  Those that do are declared this way by a call to
2157 @code{DEFVAR_LISP()} in the @code{vars_of_*()} initializer for the
2158 module.  What this does is create a special @dfn{symbol-value-forward}
2159 Lisp object that contains a pointer to the C variable, intern a symbol
2160 whose name is as specified in the call to @code{DEFVAR_LISP()}, and set
2161 its value to the symbol-value-forward Lisp object; it also calls
2162 @code{staticpro()} on the C variable to tell the garbage-collection
2163 mechanism about the variable.  When @code{eval} (or actually
2164 @code{symbol-value}) encounters this special object in the process of
2165 retrieving a variable's value, it follows the indirection to the C
2166 variable and gets its value.  @code{setq} does similar things so that
2167 the C variable gets changed.
2168
2169   Whether or not you @code{DEFVAR_LISP()} a variable, you need to
2170 initialize it in the @code{vars_of_*()} function; otherwise it will end
2171 up as all zeroes, which is the integer 0 (@emph{not} @code{nil}), and
2172 this is probably not what you want.  Also, if the variable is not
2173 @code{DEFVAR_LISP()}ed, @strong{you must call} @code{staticpro()} on the
2174 C variable in the @code{vars_of_*()} function.  Otherwise, the
2175 garbage-collection mechanism won't know that the object in this variable
2176 is in use, and will happily collect it and reuse its storage for another
2177 Lisp object, and you will be the one who's unhappy when you can't figure
2178 out how your variable got overwritten.
2179
2180 @node Coding for Mule
2181 @section Coding for Mule
2182 @cindex Coding for Mule
2183
2184 Although Mule support is not compiled by default in XEmacs, many people
2185 are using it, and we consider it crucial that new code works correctly
2186 with multibyte characters.  This is not hard; it is only a matter of
2187 following several simple user-interface guidelines.  Even if you never
2188 compile with Mule, with a little practice you will find it quite easy
2189 to code Mule-correctly.
2190
2191 Note that these guidelines are not necessarily tied to the current Mule
2192 implementation; they are also a good idea to follow on the grounds of
2193 code generalization for future I18N work.
2194
2195 @menu
2196 * Character-Related Data Types::
2197 * Working With Character and Byte Positions::
2198 * Conversion to and from External Data::
2199 * General Guidelines for Writing Mule-Aware Code::
2200 * An Example of Mule-Aware Code::
2201 @end menu
2202
2203 @node Character-Related Data Types
2204 @subsection Character-Related Data Types
2205
2206 First, let's review the basic character-related datatypes used by
2207 XEmacs.  Note that the separate @code{typedef}s are not mandatory in the
2208 current implementation (all of them boil down to @code{unsigned char} or
2209 @code{int}), but they improve clarity of code a great deal, because one
2210 glance at the declaration can tell the intended use of the variable.
2211
2212 @table @code
2213 @item Emchar
2214 @cindex Emchar
2215 An @code{Emchar} holds a single Emacs character.
2216
2217 Obviously, the equality between characters and bytes is lost in the Mule
2218 world.  Characters can be represented by one or more bytes in the
2219 buffer, and @code{Emchar} is the C type large enough to hold any
2220 character.
2221
2222 Without Mule support, an @code{Emchar} is equivalent to an
2223 @code{unsigned char}.
2224
2225 @item Bufbyte
2226 @cindex Bufbyte
2227 The data representing the text in a buffer or string is logically a set
2228 of @code{Bufbyte}s.
2229
2230 XEmacs does not work with character formats all the time; when reading
2231 characters from the outside, it decodes them to an internal format, and
2232 likewise encodes them when writing.  @code{Bufbyte} (in fact
2233 @code{unsigned char}) is the basic unit of XEmacs internal buffers and
2234 strings format.
2235
2236 One character can correspond to one or more @code{Bufbyte}s.  In the
2237 current implementation, an ASCII character is represented by the same
2238 @code{Bufbyte}, and extended characters are represented by a sequence of
2239 @code{Bufbyte}s.
2240
2241 Without Mule support, a @code{Bufbyte} is equivalent to an
2242 @code{Emchar}.
2243
2244 @item Bufpos
2245 @itemx Charcount
2246 @cindex Bufpos
2247 @cindex Charcount
2248 A @code{Bufpos} represents a character position in a buffer or string.
2249 A @code{Charcount} represents a number (count) of characters.
2250 Logically, subtracting two @code{Bufpos} values yields a
2251 @code{Charcount} value.  Although all of these are @code{typedef}ed to
2252 @code{int}, we use them in preference to @code{int} to make it clear
2253 what sort of position is being used.
2254
2255 @code{Bufpos} and @code{Charcount} values are the only ones that are
2256 ever visible to Lisp.
2257
2258 @item Bytind
2259 @itemx Bytecount
2260 @cindex Bytind
2261 @cindex Bytecount
2262 A @code{Bytind} represents a byte position in a buffer or string.  A
2263 @code{Bytecount} represents the distance between two positions in bytes.
2264 The relationship between @code{Bytind} and @code{Bytecount} is the same
2265 as the relationship between @code{Bufpos} and @code{Charcount}.
2266
2267 @item Extbyte
2268 @itemx Extcount
2269 @cindex Extbyte
2270 @cindex Extcount
2271 When dealing with the outside world, XEmacs works with @code{Extbyte}s,
2272 which are equivalent to @code{unsigned char}.  Obviously, an
2273 @code{Extcount} is the distance between two @code{Extbyte}s.  Extbytes
2274 and Extcounts are not all that frequent in XEmacs code.
2275 @end table
2276
2277 @node Working With Character and Byte Positions
2278 @subsection Working With Character and Byte Positions
2279
2280 Now that we have defined the basic character-related types, we can look
2281 at the macros and functions designed for work with them and for
2282 conversion between them.  Most of these macros are defined in
2283 @file{buffer.h}, and we don't discuss all of them here, but only the
2284 most important ones.  Examining the existing code is the best way to
2285 learn about them.
2286
2287 @table @code
2288 @item MAX_EMCHAR_LEN
2289 @cindex MAX_EMCHAR_LEN
2290 This preprocessor constant is the maximum number of buffer bytes per
2291 Emacs character, i.e. the byte length of an @code{Emchar}.  It is useful
2292 when allocating temporary strings to keep a known number of characters.
2293 For instance:
2294
2295 @example
2296 @group
2297 @{
2298   Charcount cclen;
2299   ...
2300   @{
2301     /* Allocate place for @var{cclen} characters. */
2302     Bufbyte *buf = (Bufbyte *)alloca (cclen * MAX_EMCHAR_LEN);
2303 ...
2304 @end group
2305 @end example
2306
2307 If you followed the previous section, you can guess that, logically,
2308 multiplying a @code{Charcount} value with @code{MAX_EMCHAR_LEN} produces
2309 a @code{Bytecount} value.
2310
2311 In the current Mule implementation, @code{MAX_EMCHAR_LEN} equals 4.
2312 Without Mule, it is 1.
2313
2314 @item charptr_emchar
2315 @itemx set_charptr_emchar
2316 @cindex charptr_emchar
2317 @cindex set_charptr_emchar
2318 The @code{charptr_emchar} macro takes a @code{Bufbyte} pointer and
2319 returns the @code{Emchar} stored at that position.  If it were a
2320 function, its prototype would be:
2321
2322 @example
2323 Emchar charptr_emchar (Bufbyte *p);
2324 @end example
2325
2326 @code{set_charptr_emchar} stores an @code{Emchar} to the specified byte
2327 position.  It returns the number of bytes stored:
2328
2329 @example
2330 Bytecount set_charptr_emchar (Bufbyte *p, Emchar c);
2331 @end example
2332
2333 It is important to note that @code{set_charptr_emchar} is safe only for
2334 appending a character at the end of a buffer, not for overwriting a
2335 character in the middle.  This is because the width of characters
2336 varies, and @code{set_charptr_emchar} cannot resize the string if it
2337 writes, say, a two-byte character where a single-byte character used to
2338 reside.
2339
2340 A typical use of @code{set_charptr_emchar} can be demonstrated by this
2341 example, which copies characters from buffer @var{buf} to a temporary
2342 string of Bufbytes.
2343
2344 @example
2345 @group
2346 @{
2347   Bufpos pos;
2348   for (pos = beg; pos < end; pos++)
2349     @{
2350       Emchar c = BUF_FETCH_CHAR (buf, pos);
2351       p += set_charptr_emchar (buf, c);
2352     @}
2353 @}
2354 @end group
2355 @end example
2356
2357 Note how @code{set_charptr_emchar} is used to store the @code{Emchar}
2358 and increment the counter, at the same time.
2359
2360 @item INC_CHARPTR
2361 @itemx DEC_CHARPTR
2362 @cindex INC_CHARPTR
2363 @cindex DEC_CHARPTR
2364 These two macros increment and decrement a @code{Bufbyte} pointer,
2365 respectively.  They will adjust the pointer by the appropriate number of
2366 bytes according to the byte length of the character stored there.  Both
2367 macros assume that the memory address is located at the beginning of a
2368 valid character.
2369
2370 Without Mule support, @code{INC_CHARPTR (p)} and @code{DEC_CHARPTR (p)}
2371 simply expand to @code{p++} and @code{p--}, respectively.
2372
2373 @item bytecount_to_charcount
2374 @cindex bytecount_to_charcount
2375 Given a pointer to a text string and a length in bytes, return the
2376 equivalent length in characters.
2377
2378 @example
2379 Charcount bytecount_to_charcount (Bufbyte *p, Bytecount bc);
2380 @end example
2381
2382 @item charcount_to_bytecount
2383 @cindex charcount_to_bytecount
2384 Given a pointer to a text string and a length in characters, return the
2385 equivalent length in bytes.
2386
2387 @example
2388 Bytecount charcount_to_bytecount (Bufbyte *p, Charcount cc);
2389 @end example
2390
2391 @item charptr_n_addr
2392 @cindex charptr_n_addr
2393 Return a pointer to the beginning of the character offset @var{cc} (in
2394 characters) from @var{p}.
2395
2396 @example
2397 Bufbyte *charptr_n_addr (Bufbyte *p, Charcount cc);
2398 @end example
2399 @end table
2400
2401 @node Conversion to and from External Data
2402 @subsection Conversion to and from External Data
2403
2404 When an external function, such as a C library function, returns a
2405 @code{char} pointer, you should almost never treat it as @code{Bufbyte}.
2406 This is because these returned strings may contain 8bit characters which
2407 can be misinterpreted by XEmacs, and cause a crash.  Likewise, when
2408 exporting a piece of internal text to the outside world, you should
2409 always convert it to an appropriate external encoding, lest the internal
2410 stuff (such as the infamous \201 characters) leak out.
2411
2412 The interface to conversion between the internal and external
2413 representations of text are the numerous conversion macros defined in
2414 @file{buffer.h}.  Before looking at them, we'll look at the external
2415 formats supported by these macros.
2416
2417 Currently meaningful formats are @code{FORMAT_BINARY},
2418 @code{FORMAT_FILENAME}, @code{FORMAT_OS}, and @code{FORMAT_CTEXT}.  Here
2419 is a description of these.
2420
2421 @table @code
2422 @item FORMAT_BINARY
2423 Binary format.  This is the simplest format and is what we use in the
2424 absence of a more appropriate format.  This converts according to the
2425 @code{binary} coding system:
2426
2427 @enumerate a
2428 @item
2429 On input, bytes 0--255 are converted into characters 0--255.
2430 @item
2431 On output, characters 0--255 are converted into bytes 0--255 and other
2432 characters are converted into `X'.
2433 @end enumerate
2434
2435 @item FORMAT_FILENAME
2436 Format used for filenames.  In the original Mule, this is user-definable
2437 with the @code{pathname-coding-system} variable.  For the moment, we
2438 just use the @code{binary} coding system.
2439
2440 @item FORMAT_OS
2441 Format used for the external Unix environment---@code{argv[]}, stuff
2442 from @code{getenv()}, stuff from the @file{/etc/passwd} file, etc.
2443
2444 Perhaps should be the same as FORMAT_FILENAME.
2445
2446 @item FORMAT_CTEXT
2447 Compound--text format.  This is the standard X format used for data
2448 stored in properties, selections, and the like.  This is an 8-bit
2449 no-lock-shift ISO2022 coding system.
2450 @end table
2451
2452 The macros to convert between these formats and the internal format, and
2453 vice versa, follow.
2454
2455 @table @code
2456 @item GET_CHARPTR_INT_DATA_ALLOCA
2457 @itemx GET_CHARPTR_EXT_DATA_ALLOCA
2458 These two are the most basic conversion macros.
2459 @code{GET_CHARPTR_INT_DATA_ALLOCA} converts external data to internal
2460 format, and @code{GET_CHARPTR_EXT_DATA_ALLOCA} converts the other way
2461 around.  The arguments each of these receives are @var{ptr} (pointer to
2462 the text in external format), @var{len} (length of texts in bytes),
2463 @var{fmt} (format of the external text), @var{ptr_out} (lvalue to which
2464 new text should be copied), and @var{len_out} (lvalue which will be
2465 assigned the length of the internal text in bytes).  The resulting text
2466 is stored to a stack-allocated buffer.  If the text doesn't need
2467 changing, these macros will do nothing, except for setting
2468 @var{len_out}.
2469
2470 The macros above take many arguments which makes them unwieldy.  For
2471 this reason, a number of convenience macros are defined with obvious
2472 functionality, but accepting less arguments.  The general rule is that
2473 macros with @samp{INT} in their name convert text to internal Emacs
2474 representation, whereas the @samp{EXT} macros convert to external
2475 representation.
2476
2477 @item GET_C_CHARPTR_INT_DATA_ALLOCA
2478 @itemx GET_C_CHARPTR_EXT_DATA_ALLOCA
2479 As their names imply, these macros work on C char pointers, which are
2480 zero-terminated, and thus do not need @var{len} or @var{len_out}
2481 parameters.
2482
2483 @item GET_STRING_EXT_DATA_ALLOCA
2484 @itemx GET_C_STRING_EXT_DATA_ALLOCA
2485 These two macros convert a Lisp string into an external representation.
2486 The difference between them is that @code{GET_STRING_EXT_DATA_ALLOCA}
2487 stores its output to a generic string, providing @var{len_out}, the
2488 length of the resulting external string.  On the other hand,
2489 @code{GET_C_STRING_EXT_DATA_ALLOCA} assumes that the caller will be
2490 satisfied with output string being zero-terminated.
2491
2492 Note that for Lisp strings only one conversion direction makes sense.
2493
2494 @item GET_C_CHARPTR_EXT_BINARY_DATA_ALLOCA
2495 @itemx GET_CHARPTR_EXT_BINARY_DATA_ALLOCA
2496 @itemx GET_STRING_BINARY_DATA_ALLOCA
2497 @itemx GET_C_STRING_BINARY_DATA_ALLOCA
2498 @itemx GET_C_CHARPTR_EXT_FILENAME_DATA_ALLOCA
2499 @itemx ...
2500 These macros convert internal text to a specific external
2501 representation, with the external format being encoded into the name of
2502 the macro.  Note that the @code{GET_STRING_...} and
2503 @code{GET_C_STRING...}  macros lack the @samp{EXT} tag, because they
2504 only make sense in that direction.
2505
2506 @item GET_C_CHARPTR_INT_BINARY_DATA_ALLOCA
2507 @itemx GET_CHARPTR_INT_BINARY_DATA_ALLOCA
2508 @itemx GET_C_CHARPTR_INT_FILENAME_DATA_ALLOCA
2509 @itemx ...
2510 These macros convert external text of a specific format to its internal
2511 representation, with the external format being incoded into the name of
2512 the macro.
2513 @end table
2514
2515 @node General Guidelines for Writing Mule-Aware Code
2516 @subsection General Guidelines for Writing Mule-Aware Code
2517
2518 This section contains some general guidance on how to write Mule-aware
2519 code, as well as some pitfalls you should avoid.
2520
2521 @table @emph
2522 @item Never use @code{char} and @code{char *}.
2523 In XEmacs, the use of @code{char} and @code{char *} is almost always a
2524 mistake.  If you want to manipulate an Emacs character from ``C'', use
2525 @code{Emchar}.  If you want to examine a specific octet in the internal
2526 format, use @code{Bufbyte}.  If you want a Lisp-visible character, use a
2527 @code{Lisp_Object} and @code{make_char}.  If you want a pointer to move
2528 through the internal text, use @code{Bufbyte *}.  Also note that you
2529 almost certainly do not need @code{Emchar *}.
2530
2531 @item Be careful not to confuse @code{Charcount}, @code{Bytecount}, and @code{Bufpos}.
2532 The whole point of using different types is to avoid confusion about the
2533 use of certain variables.  Lest this effect be nullified, you need to be
2534 careful about using the right types.
2535
2536 @item Always convert external data
2537 It is extremely important to always convert external data, because
2538 XEmacs can crash if unexpected 8bit sequences are copied to its internal
2539 buffers literally.
2540
2541 This means that when a system function, such as @code{readdir}, returns
2542 a string, you need to convert it using one of the conversion macros
2543 described in the previous chapter, before passing it further to Lisp.
2544 In the case of @code{readdir}, you would use the
2545 @code{GET_C_CHARPTR_INT_FILENAME_DATA_ALLOCA} macro.
2546
2547 Also note that many internal functions, such as @code{make_string},
2548 accept Bufbytes, which removes the need for them to convert the data
2549 they receive.  This increases efficiency because that way external data
2550 needs to be decoded only once, when it is read.  After that, it is
2551 passed around in internal format.
2552 @end table
2553
2554 @node An Example of Mule-Aware Code
2555 @subsection An Example of Mule-Aware Code
2556
2557 As an example of Mule-aware code, we shall will analyze the
2558 @code{string} function, which conses up a Lisp string from the character
2559 arguments it receives.  Here is the definition, pasted from
2560 @code{alloc.c}:
2561
2562 @example
2563 @group
2564 DEFUN ("string", Fstring, 0, MANY, 0, /*
2565 Concatenate all the argument characters and make the result a string.
2566 */
2567        (int nargs, Lisp_Object *args))
2568 @{
2569   Bufbyte *storage = alloca_array (Bufbyte, nargs * MAX_EMCHAR_LEN);
2570   Bufbyte *p = storage;
2571
2572   for (; nargs; nargs--, args++)
2573     @{
2574       Lisp_Object lisp_char = *args;
2575       CHECK_CHAR_COERCE_INT (lisp_char);
2576       p += set_charptr_emchar (p, XCHAR (lisp_char));
2577     @}
2578   return make_string (storage, p - storage);
2579 @}
2580 @end group
2581 @end example
2582
2583 Now we can analyze the source line by line.
2584
2585 Obviously, string will be as long as there are arguments to the
2586 function.  This is why we allocate @code{MAX_EMCHAR_LEN} * @var{nargs}
2587 bytes on the stack, i.e. the worst-case number of bytes for @var{nargs}
2588 @code{Emchar}s to fit in the string.
2589
2590 Then, the loop checks that each element is a character, converting
2591 integers in the process.  Like many other functions in XEmacs, this
2592 function silently accepts integers where characters are expected, for
2593 historical and compatibility reasons.  Unless you know what you are
2594 doing, @code{CHECK_CHAR} will also suffice.  @code{XCHAR (lisp_char)}
2595 extracts the @code{Emchar} from the @code{Lisp_Object}, and
2596 @code{set_charptr_emchar} stores it to storage, increasing @code{p} in
2597 the process.
2598
2599 Other instructive examples of correct coding under Mule can be found all
2600 over the XEmacs code.  For starters, I recommend
2601 @code{Fnormalize_menu_item_name} in @file{menubar.c}.  After you have
2602 understood this section of the manual and studied the examples, you can
2603 proceed writing new Mule-aware code.
2604
2605 @node Techniques for XEmacs Developers
2606 @section Techniques for XEmacs Developers
2607
2608 To make a quantified XEmacs, do: @code{make quantmacs}.
2609
2610 You simply can't dump Quantified and Purified images.  Run the image
2611 like so:  @code{quantmacs -batch -l loadup.el run-temacs @var{xemacs-args...}}.
2612
2613 Before you go through the trouble, are you compiling with all
2614 debugging and error-checking off?  If not try that first.  Be warned
2615 that while Quantify is directly responsible for quite a few
2616 optimizations which have been made to XEmacs, doing a run which
2617 generates results which can be acted upon is not necessarily a trivial
2618 task.
2619
2620 Also, if you're still willing to do some runs make sure you configure
2621 with the @samp{--quantify} flag.  That will keep Quantify from starting
2622 to record data until after the loadup is completed and will shut off
2623 recording right before it shuts down (which generates enough bogus data
2624 to throw most results off).  It also enables three additional elisp
2625 commands: @code{quantify-start-recording-data},
2626 @code{quantify-stop-recording-data} and @code{quantify-clear-data}.
2627
2628 If you want to make XEmacs faster, target your favorite slow benchmark,
2629 run a profiler like Quantify, @code{gprof}, or @code{tcov}, and figure
2630 out where the cycles are going.  Specific projects:
2631
2632 @itemize @bullet
2633 @item
2634 Make the garbage collector faster.  Figure out how to write an
2635 incremental garbage collector.
2636 @item
2637 Write a compiler that takes bytecode and spits out C code.
2638 Unfortunately, you will then need a C compiler and a more fully
2639 developed module system.
2640 @item
2641 Speed up redisplay.
2642 @item
2643 Speed up syntax highlighting.  Maybe moving some of the syntax
2644 highlighting capabilities into C would make a difference.
2645 @item
2646 Implement tail recursion in Emacs Lisp (hard!).
2647 @end itemize
2648
2649 Unfortunately, Emacs Lisp is slow, and is going to stay slow.  Function
2650 calls in elisp are especially expensive.  Iterating over a long list is
2651 going to be 30 times faster implemented in C than in Elisp.
2652
2653 To get started debugging XEmacs, take a look at the @file{gdbinit} and
2654 @file{dbxrc} files in the @file{src} directory.
2655 @xref{Q2.1.15 - How to Debug an XEmacs problem with a debugger,,,
2656 xemacs-faq, XEmacs FAQ}.
2657
2658 After making source code changes, run @code{make check} to ensure that
2659 you haven't introduced any regressions.  If you're feeling ambitious,
2660 you can try to improve the test suite in @file{tests/automated}.
2661
2662 Here are things to know when you create a new source file:
2663
2664 @itemize @bullet
2665 @item
2666 All @file{.c} files should @code{#include <config.h>} first.  Almost all
2667 @file{.c} files should @code{#include "lisp.h"} second.
2668
2669 @item
2670 Generated header files should be included using the @code{#include <...>} syntax,
2671 not the @code{#include "..."} syntax.  The generated headers are:
2672
2673 @file{config.h puresize-adjust.h sheap-adjust.h paths.h Emacs.ad.h}
2674
2675 The basic rule is that you should assume builds using @code{--srcdir}
2676 and the @code{#include <...>} syntax needs to be used when the
2677 to-be-included generated file is in a potentially different directory
2678 @emph{at compile time}.  The non-obvious C rule is that @code{#include "..."}
2679 means to search for the included file in the same directory as the
2680 including file, @emph{not} in the current directory.
2681
2682 @item
2683 Header files should @emph{not} include @code{<config.h>} and
2684 @code{"lisp.h"}.  It is the responsibility of the @file{.c} files that
2685 use it to do so.
2686
2687 @item
2688 If the header uses @code{INLINE}, either directly or through
2689 @code{DECLARE_LRECORD}, then it must be added to @file{inline.c}'s
2690 includes.
2691
2692 @item
2693 Try compiling at least once with
2694
2695 @example
2696 gcc --with-mule --with-union-type --error-checking=all
2697 @end example
2698
2699 @item
2700 Did I mention that you should run the test suite?
2701 @example
2702 make check
2703 @end example
2704 @end itemize
2705
2706
2707 @node A Summary of the Various XEmacs Modules, Allocation of Objects in XEmacs Lisp, Rules When Writing New C Code, Top
2708 @chapter A Summary of the Various XEmacs Modules
2709
2710   This is accurate as of XEmacs 20.0.
2711
2712 @menu
2713 * Low-Level Modules::
2714 * Basic Lisp Modules::
2715 * Modules for Standard Editing Operations::
2716 * Editor-Level Control Flow Modules::
2717 * Modules for the Basic Displayable Lisp Objects::
2718 * Modules for other Display-Related Lisp Objects::
2719 * Modules for the Redisplay Mechanism::
2720 * Modules for Interfacing with the File System::
2721 * Modules for Other Aspects of the Lisp Interpreter and Object System::
2722 * Modules for Interfacing with the Operating System::
2723 * Modules for Interfacing with X Windows::
2724 * Modules for Internationalization::
2725 @end menu
2726
2727 @node Low-Level Modules
2728 @section Low-Level Modules
2729
2730 @example
2731 config.h
2732 @end example
2733
2734 This is automatically generated from @file{config.h.in} based on the
2735 results of configure tests and user-selected optional features and
2736 contains preprocessor definitions specifying the nature of the
2737 environment in which XEmacs is being compiled.
2738
2739
2740
2741 @example
2742 paths.h
2743 @end example
2744
2745 This is automatically generated from @file{paths.h.in} based on supplied
2746 configure values, and allows for non-standard installed configurations
2747 of the XEmacs directories.  It's currently broken, though.
2748
2749
2750
2751 @example
2752 emacs.c
2753 signal.c
2754 @end example
2755
2756 @file{emacs.c} contains @code{main()} and other code that performs the most
2757 basic environment initializations and handles shutting down the XEmacs
2758 process (this includes @code{kill-emacs}, the normal way that XEmacs is
2759 exited; @code{dump-emacs}, which is used during the build process to
2760 write out the XEmacs executable; @code{run-emacs-from-temacs}, which can
2761 be used to start XEmacs directly when temacs has finished loading all
2762 the Lisp code; and emergency code to handle crashes [XEmacs tries to
2763 auto-save all files before it crashes]).
2764
2765 Low-level code that directly interacts with the Unix signal mechanism,
2766 however, is in @file{signal.c}.  Note that this code does not handle system
2767 dependencies in interfacing to signals; that is handled using the
2768 @file{syssignal.h} header file, described in section J below.
2769
2770
2771
2772 @example
2773 unexaix.c
2774 unexalpha.c
2775 unexapollo.c
2776 unexconvex.c
2777 unexec.c
2778 unexelf.c
2779 unexelfsgi.c
2780 unexencap.c
2781 unexenix.c
2782 unexfreebsd.c
2783 unexfx2800.c
2784 unexhp9k3.c
2785 unexhp9k800.c
2786 unexmips.c
2787 unexnext.c
2788 unexsol2.c
2789 unexsunos4.c
2790 @end example
2791
2792 These modules contain code dumping out the XEmacs executable on various
2793 different systems. (This process is highly machine-specific and
2794 requires intimate knowledge of the executable format and the memory map
2795 of the process.) Only one of these modules is actually used; this is
2796 chosen by @file{configure}.
2797
2798
2799
2800 @example
2801 crt0.c
2802 lastfile.c
2803 pre-crt0.c
2804 @end example
2805
2806 These modules are used in conjunction with the dump mechanism.  On some
2807 systems, an alternative version of the C startup code (the actual code
2808 that receives control from the operating system when the process is
2809 started, and which calls @code{main()}) is required so that the dumping
2810 process works properly; @file{crt0.c} provides this.
2811
2812 @file{pre-crt0.c} and @file{lastfile.c} should be the very first and
2813 very last file linked, respectively. (Actually, this is not really true.
2814 @file{lastfile.c} should be after all Emacs modules whose initialized
2815 data should be made constant, and before all other Emacs files and all
2816 libraries.  In particular, the allocation modules @file{gmalloc.c},
2817 @file{alloca.c}, etc. are normally placed past @file{lastfile.c}, and
2818 all of the files that implement Xt widget classes @emph{must} be placed
2819 after @file{lastfile.c} because they contain various structures that
2820 must be statically initialized and into which Xt writes at various
2821 times.) @file{pre-crt0.c} and @file{lastfile.c} contain exported symbols
2822 that are used to determine the start and end of XEmacs' initialized
2823 data space when dumping.
2824
2825
2826
2827 @example
2828 alloca.c
2829 free-hook.c
2830 getpagesize.h
2831 gmalloc.c
2832 malloc.c
2833 mem-limits.h
2834 ralloc.c
2835 vm-limit.c
2836 @end example
2837
2838 These handle basic C allocation of memory.  @file{alloca.c} is an emulation of
2839 the stack allocation function @code{alloca()} on machines that lack
2840 this. (XEmacs makes extensive use of @code{alloca()} in its code.)
2841
2842 @file{gmalloc.c} and @file{malloc.c} are two implementations of the standard C
2843 functions @code{malloc()}, @code{realloc()} and @code{free()}.  They are
2844 often used in place of the standard system-provided @code{malloc()}
2845 because they usually provide a much faster implementation, at the
2846 expense of additional memory use.  @file{gmalloc.c} is a newer implementation
2847 that is much more memory-efficient for large allocations than @file{malloc.c},
2848 and should always be preferred if it works. (At one point, @file{gmalloc.c}
2849 didn't work on some systems where @file{malloc.c} worked; but this should be
2850 fixed now.)
2851
2852 @cindex relocating allocator
2853 @file{ralloc.c} is the @dfn{relocating allocator}.  It provides
2854 functions similar to @code{malloc()}, @code{realloc()} and @code{free()}
2855 that allocate memory that can be dynamically relocated in memory.  The
2856 advantage of this is that allocated memory can be shuffled around to
2857 place all the free memory at the end of the heap, and the heap can then
2858 be shrunk, releasing the memory back to the operating system.  The use
2859 of this can be controlled with the configure option @code{--rel-alloc};
2860 if enabled, memory allocated for buffers will be relocatable, so that if
2861 a very large file is visited and the buffer is later killed, the memory
2862 can be released to the operating system.  (The disadvantage of this
2863 mechanism is that it can be very slow.  On systems with the
2864 @code{mmap()} system call, the XEmacs version of @file{ralloc.c} uses
2865 this to move memory around without actually having to block-copy it,
2866 which can speed things up; but it can still cause noticeable performance
2867 degradation.)
2868
2869 @file{free-hook.c} contains some debugging functions for checking for invalid
2870 arguments to @code{free()}.
2871
2872 @file{vm-limit.c} contains some functions that warn the user when memory is
2873 getting low.  These are callback functions that are called by @file{gmalloc.c}
2874 and @file{malloc.c} at appropriate times.
2875
2876 @file{getpagesize.h} provides a uniform interface for retrieving the size of a
2877 page in virtual memory.  @file{mem-limits.h} provides a uniform interface for
2878 retrieving the total amount of available virtual memory.  Both are
2879 similar in spirit to the @file{sys*.h} files described in section J, below.
2880
2881
2882
2883 @example
2884 blocktype.c
2885 blocktype.h
2886 dynarr.c
2887 @end example
2888
2889 These implement a couple of basic C data types to facilitate memory
2890 allocation.  The @code{Blocktype} type efficiently manages the
2891 allocation of fixed-size blocks by minimizing the number of times that
2892 @code{malloc()} and @code{free()} are called.  It allocates memory in
2893 large chunks, subdivides the chunks into blocks of the proper size, and
2894 returns the blocks as requested.  When blocks are freed, they are placed
2895 onto a linked list, so they can be efficiently reused.  This data type
2896 is not much used in XEmacs currently, because it's a fairly new
2897 addition.
2898
2899 @cindex dynamic array
2900 The @code{Dynarr} type implements a @dfn{dynamic array}, which is
2901 similar to a standard C array but has no fixed limit on the number of
2902 elements it can contain.  Dynamic arrays can hold elements of any type,
2903 and when you add a new element, the array automatically resizes itself
2904 if it isn't big enough.  Dynarrs are extensively used in the redisplay
2905 mechanism.
2906
2907
2908
2909 @example
2910 inline.c
2911 @end example
2912
2913 This module is used in connection with inline functions (available in
2914 some compilers).  Often, inline functions need to have a corresponding
2915 non-inline function that does the same thing.  This module is where they
2916 reside.  It contains no actual code, but defines some special flags that
2917 cause inline functions defined in header files to be rendered as actual
2918 functions.  It then includes all header files that contain any inline
2919 function definitions, so that each one gets a real function equivalent.
2920
2921
2922
2923 @example
2924 debug.c
2925 debug.h
2926 @end example
2927
2928 These functions provide a system for doing internal consistency checks
2929 during code development.  This system is not currently used; instead the
2930 simpler @code{assert()} macro is used along with the various checks
2931 provided by the @samp{--error-check-*} configuration options.
2932
2933
2934
2935 @example
2936 prefix-args.c
2937 @end example
2938
2939 This is actually the source for a small, self-contained program
2940 used during building.
2941
2942
2943 @example
2944 universe.h
2945 @end example
2946
2947 This is not currently used.
2948
2949
2950
2951 @node Basic Lisp Modules
2952 @section Basic Lisp Modules
2953
2954 @example
2955 emacsfns.h
2956 lisp-disunion.h
2957 lisp-union.h
2958 lisp.h
2959 lrecord.h
2960 symsinit.h
2961 @end example
2962
2963 These are the basic header files for all XEmacs modules.  Each module
2964 includes @file{lisp.h}, which brings the other header files in.
2965 @file{lisp.h} contains the definitions of the structures and extractor
2966 and constructor macros for the basic Lisp objects and various other
2967 basic definitions for the Lisp environment, as well as some
2968 general-purpose definitions (e.g. @code{min()} and @code{max()}).
2969 @file{lisp.h} includes either @file{lisp-disunion.h} or
2970 @file{lisp-union.h}, depending on whether @code{USE_UNION_TYPE} is
2971 defined.  These files define the typedef of the Lisp object itself (as
2972 described above) and the low-level macros that hide the actual
2973 implementation of the Lisp object.  All extractor and constructor macros
2974 for particular types of Lisp objects are defined in terms of these
2975 low-level macros.
2976
2977 As a general rule, all typedefs should go into the typedefs section of
2978 @file{lisp.h} rather than into a module-specific header file even if the
2979 structure is defined elsewhere.  This allows function prototypes that
2980 use the typedef to be placed into other header files.  Forward structure
2981 declarations (i.e. a simple declaration like @code{struct foo;} where
2982 the structure itself is defined elsewhere) should be placed into the
2983 typedefs section as necessary.
2984
2985 @file{lrecord.h} contains the basic structures and macros that implement
2986 all record-type Lisp objects -- i.e. all objects whose type is a field
2987 in their C structure, which includes all objects except the few most
2988 basic ones.
2989
2990 @file{lisp.h} contains prototypes for most of the exported functions in
2991 the various modules.  Lisp primitives defined using @code{DEFUN} that
2992 need to be called by C code should be declared using @code{EXFUN}.
2993 Other function prototypes should be placed either into the appropriate
2994 section of @code{lisp.h}, or into a module-specific header file,
2995 depending on how general-purpose the function is and whether it has
2996 special-purpose argument types requiring definitions not in
2997 @file{lisp.h}.)  All initialization functions are prototyped in
2998 @file{symsinit.h}.
2999
3000
3001
3002 @example
3003 alloc.c
3004 pure.c
3005 puresize.h
3006 @end example
3007
3008 The large module @file{alloc.c} implements all of the basic allocation and
3009 garbage collection for Lisp objects.  The most commonly used Lisp
3010 objects are allocated in chunks, similar to the Blocktype data type
3011 described above; others are allocated in individually @code{malloc()}ed
3012 blocks.  This module provides the foundation on which all other aspects
3013 of the Lisp environment sit, and is the first module initialized at
3014 startup.
3015
3016 Note that @file{alloc.c} provides a series of generic functions that are
3017 not dependent on any particular object type, and interfaces to
3018 particular types of objects using a standardized interface of
3019 type-specific methods.  This scheme is a fundamental principle of
3020 object-oriented programming and is heavily used throughout XEmacs.  The
3021 great advantage of this is that it allows for a clean separation of
3022 functionality into different modules -- new classes of Lisp objects, new
3023 event interfaces, new device types, new stream interfaces, etc. can be
3024 added transparently without affecting code anywhere else in XEmacs.
3025 Because the different subsystems are divided into general and specific
3026 code, adding a new subtype within a subsystem will in general not
3027 require changes to the generic subsystem code or affect any of the other
3028 subtypes in the subsystem; this provides a great deal of robustness to
3029 the XEmacs code.
3030
3031 @cindex pure space
3032 @file{pure.c} contains the declaration of the @dfn{purespace} array.
3033 Pure space is a hack used to place some constant Lisp data into the code
3034 segment of the XEmacs executable, even though the data needs to be
3035 initialized through function calls.  (See above in section VIII for more
3036 info about this.)  During startup, certain sorts of data is
3037 automatically copied into pure space, and other data is copied manually
3038 in some of the basic Lisp files by calling the function @code{purecopy},
3039 which copies the object if possible (this only works in temacs, of
3040 course) and returns the new object.  In particular, while temacs is
3041 executing, the Lisp reader automatically copies all compiled-function
3042 objects that it reads into pure space.  Since compiled-function objects
3043 are large, are never modified, and typically comprise the majority of
3044 the contents of a compiled-Lisp file, this works well.  While XEmacs is
3045 running, any attempt to modify an object that resides in pure space
3046 causes an error.  Objects in pure space are never garbage collected --
3047 almost all of the time, they're intended to be permanent, and in any
3048 case you can't write into pure space to set the mark bits.
3049
3050 @file{puresize.h} contains the declaration of the size of the pure space
3051 array.  This depends on the optional features that are compiled in, any
3052 extra purespace requested by the user at compile time, and certain other
3053 factors (e.g. 64-bit machines need more pure space because their Lisp
3054 objects are larger).  The smallest size that suffices should be used, so
3055 that there's no wasted space.  If there's not enough pure space, you
3056 will get an error during the build process, specifying how much more
3057 pure space is needed.
3058
3059
3060
3061 @example
3062 eval.c
3063 backtrace.h
3064 @end example
3065
3066 This module contains all of the functions to handle the flow of control.
3067 This includes the mechanisms of defining functions, calling functions,
3068 traversing stack frames, and binding variables; the control primitives
3069 and other special forms such as @code{while}, @code{if}, @code{eval},
3070 @code{let}, @code{and}, @code{or}, @code{progn}, etc.; handling of
3071 non-local exits, unwind-protects, and exception handlers; entering the
3072 debugger; methods for the subr Lisp object type; etc.  It does
3073 @emph{not} include the @code{read} function, the @code{print} function,
3074 or the handling of symbols and obarrays.
3075
3076 @file{backtrace.h} contains some structures related to stack frames and the
3077 flow of control.
3078
3079
3080
3081 @example
3082 lread.c
3083 @end example
3084
3085 This module implements the Lisp reader and the @code{read} function,
3086 which converts text into Lisp objects, according to the read syntax of
3087 the objects, as described above.  This is similar to the parser that is
3088 a part of all compilers.
3089
3090
3091
3092 @example
3093 print.c
3094 @end example
3095
3096 This module implements the Lisp print mechanism and the @code{print}
3097 function and related functions.  This is the inverse of the Lisp reader
3098 -- it converts Lisp objects to a printed, textual representation.
3099 (Hopefully something that can be read back in using @code{read} to get
3100 an equivalent object.)
3101
3102
3103
3104 @example
3105 general.c
3106 symbols.c
3107 symeval.h
3108 @end example
3109
3110 @file{symbols.c} implements the handling of symbols, obarrays, and
3111 retrieving the values of symbols.  Much of the code is devoted to
3112 handling the special @dfn{symbol-value-magic} objects that define
3113 special types of variables -- this includes buffer-local variables,
3114 variable aliases, variables that forward into C variables, etc.  This
3115 module is initialized extremely early (right after @file{alloc.c}),
3116 because it is here that the basic symbols @code{t} and @code{nil} are
3117 created, and those symbols are used everywhere throughout XEmacs.
3118
3119 @file{symeval.h} contains the definitions of symbol structures and the
3120 @code{DEFVAR_LISP()} and related macros for declaring variables.
3121
3122
3123
3124 @example
3125 data.c
3126 floatfns.c
3127 fns.c
3128 @end example
3129
3130 These modules implement the methods and standard Lisp primitives for all
3131 the basic Lisp object types other than symbols (which are described
3132 above).  @file{data.c} contains all the predicates (primitives that return
3133 whether an object is of a particular type); the integer arithmetic
3134 functions; and the basic accessor and mutator primitives for the various
3135 object types.  @file{fns.c} contains all the standard predicates for working
3136 with sequences (where, abstractly speaking, a sequence is an ordered set
3137 of objects, and can be represented by a list, string, vector, or
3138 bit-vector); it also contains @code{equal}, perhaps on the grounds that
3139 bulk of the operation of @code{equal} is comparing sequences.
3140 @file{floatfns.c} contains methods and primitives for floats and floating-point
3141 arithmetic.
3142
3143
3144
3145 @example
3146 bytecode.c
3147 bytecode.h
3148 @end example
3149
3150 @file{bytecode.c} implements the byte-code interpreter and
3151 compiled-function objects, and @file{bytecode.h} contains associated
3152 structures.  Note that the byte-code @emph{compiler} is written in Lisp.
3153
3154
3155
3156
3157 @node Modules for Standard Editing Operations
3158 @section Modules for Standard Editing Operations
3159
3160 @example
3161 buffer.c
3162 buffer.h
3163 bufslots.h
3164 @end example
3165
3166 @file{buffer.c} implements the @dfn{buffer} Lisp object type.  This
3167 includes functions that create and destroy buffers; retrieve buffers by
3168 name or by other properties; manipulate lists of buffers (remember that
3169 buffers are permanent objects and stored in various ordered lists);
3170 retrieve or change buffer properties; etc.  It also contains the
3171 definitions of all the built-in buffer-local variables (which can be
3172 viewed as buffer properties).  It does @emph{not} contain code to
3173 manipulate buffer-local variables (that's in @file{symbols.c}, described
3174 above); or code to manipulate the text in a buffer.
3175
3176 @file{buffer.h} defines the structures associated with a buffer and the various
3177 macros for retrieving text from a buffer and special buffer positions
3178 (e.g. @code{point}, the default location for text insertion).  It also
3179 contains macros for working with buffer positions and converting between
3180 their representations as character offsets and as byte offsets (under
3181 MULE, they are different, because characters can be multi-byte).  It is
3182 one of the largest header files.
3183
3184 @file{bufslots.h} defines the fields in the buffer structure that correspond to
3185 the built-in buffer-local variables.  It is its own header file because
3186 it is included many times in @file{buffer.c}, as a way of iterating over all
3187 the built-in buffer-local variables.
3188
3189
3190
3191 @example
3192 insdel.c
3193 insdel.h
3194 @end example
3195
3196 @file{insdel.c} contains low-level functions for inserting and deleting text in
3197 a buffer, keeping track of changed regions for use by redisplay, and
3198 calling any before-change and after-change functions that may have been
3199 registered for the buffer.  It also contains the actual functions that
3200 convert between byte offsets and character offsets.
3201
3202 @file{insdel.h} contains associated headers.
3203
3204
3205
3206 @example
3207 marker.c
3208 @end example
3209
3210 This module implements the @dfn{marker} Lisp object type, which
3211 conceptually is a pointer to a text position in a buffer that moves
3212 around as text is inserted and deleted, so as to remain in the same
3213 relative position.  This module doesn't actually move the markers around
3214 -- that's handled in @file{insdel.c}.  This module just creates them and
3215 implements the primitives for working with them.  As markers are simple
3216 objects, this does not entail much.
3217
3218 Note that the standard arithmetic primitives (e.g. @code{+}) accept
3219 markers in place of integers and automatically substitute the value of
3220 @code{marker-position} for the marker, i.e. an integer describing the
3221 current buffer position of the marker.
3222
3223
3224
3225 @example
3226 extents.c
3227 extents.h
3228 @end example
3229
3230 This module implements the @dfn{extent} Lisp object type, which is like
3231 a marker that works over a range of text rather than a single position.
3232 Extents are also much more complex and powerful than markers and have a
3233 more efficient (and more algorithmically complex) implementation.  The
3234 implementation is described in detail in comments in @file{extents.c}.
3235
3236 The code in @file{extents.c} works closely with @file{insdel.c} so that
3237 extents are properly moved around as text is inserted and deleted.
3238 There is also code in @file{extents.c} that provides information needed
3239 by the redisplay mechanism for efficient operation. (Remember that
3240 extents can have display properties that affect [sometimes drastically,
3241 as in the @code{invisible} property] the display of the text they
3242 cover.)
3243
3244
3245
3246 @example
3247 editfns.c
3248 @end example
3249
3250 @file{editfns.c} contains the standard Lisp primitives for working with
3251 a buffer's text, and calls the low-level functions in @file{insdel.c}.
3252 It also contains primitives for working with @code{point} (the default
3253 buffer insertion location).
3254
3255 @file{editfns.c} also contains functions for retrieving various
3256 characteristics from the external environment: the current time, the
3257 process ID of the running XEmacs process, the name of the user who ran
3258 this XEmacs process, etc.  It's not clear why this code is in
3259 @file{editfns.c}.
3260
3261
3262
3263 @example
3264 callint.c
3265 cmds.c
3266 commands.h
3267 @end example
3268
3269 @cindex interactive
3270 These modules implement the basic @dfn{interactive} commands,
3271 i.e. user-callable functions.  Commands, as opposed to other functions,
3272 have special ways of getting their parameters interactively (by querying
3273 the user), as opposed to having them passed in a normal function
3274 invocation.  Many commands are not really meant to be called from other
3275 Lisp functions, because they modify global state in a way that's often
3276 undesired as part of other Lisp functions.
3277
3278 @file{callint.c} implements the mechanism for querying the user for
3279 parameters and calling interactive commands.  The bulk of this module is
3280 code that parses the interactive spec that is supplied with an
3281 interactive command.
3282
3283 @file{cmds.c} implements the basic, most commonly used editing commands:
3284 commands to move around the current buffer and insert and delete
3285 characters.  These commands are implemented using the Lisp primitives
3286 defined in @file{editfns.c}.
3287
3288 @file{commands.h} contains associated structure definitions and prototypes.
3289
3290
3291
3292 @example
3293 regex.c
3294 regex.h
3295 search.c
3296 @end example
3297
3298 @file{search.c} implements the Lisp primitives for searching for text in
3299 a buffer, and some of the low-level algorithms for doing this.  In
3300 particular, the fast fixed-string Boyer-Moore search algorithm is
3301 implemented in @file{search.c}.  The low-level algorithms for doing
3302 regular-expression searching, however, are implemented in @file{regex.c}
3303 and @file{regex.h}.  These two modules are largely independent of
3304 XEmacs, and are similar to (and based upon) the regular-expression
3305 routines used in @file{grep} and other GNU utilities.
3306
3307
3308
3309 @example
3310 doprnt.c
3311 @end example
3312
3313 @file{doprnt.c} implements formatted-string processing, similar to
3314 @code{printf()} command in C.
3315
3316
3317
3318 @example
3319 undo.c
3320 @end example
3321
3322 This module implements the undo mechanism for tracking buffer changes.
3323 Most of this could be implemented in Lisp.
3324
3325
3326
3327 @node Editor-Level Control Flow Modules
3328 @section Editor-Level Control Flow Modules
3329
3330 @example
3331 event-Xt.c
3332 event-stream.c
3333 event-tty.c
3334 events.c
3335 events.h
3336 @end example
3337
3338 These implement the handling of events (user input and other system
3339 notifications).
3340
3341 @file{events.c} and @file{events.h} define the @dfn{event} Lisp object
3342 type and primitives for manipulating it.
3343
3344 @file{event-stream.c} implements the basic functions for working with
3345 event queues, dispatching an event by looking it up in relevant keymaps
3346 and such, and handling timeouts; this includes the primitives
3347 @code{next-event} and @code{dispatch-event}, as well as related
3348 primitives such as @code{sit-for}, @code{sleep-for}, and
3349 @code{accept-process-output}. (@file{event-stream.c} is one of the
3350 hairiest and trickiest modules in XEmacs.  Beware!  You can easily mess
3351 things up here.)
3352
3353 @file{event-Xt.c} and @file{event-tty.c} implement the low-level
3354 interfaces onto retrieving events from Xt (the X toolkit) and from TTY's
3355 (using @code{read()} and @code{select()}), respectively.  The event
3356 interface enforces a clean separation between the specific code for
3357 interfacing with the operating system and the generic code for working
3358 with events, by defining an API of basic, low-level event methods;
3359 @file{event-Xt.c} and @file{event-tty.c} are two different
3360 implementations of this API.  To add support for a new operating system
3361 (e.g. NeXTstep), one merely needs to provide another implementation of
3362 those API functions.
3363
3364 Note that the choice of whether to use @file{event-Xt.c} or
3365 @file{event-tty.c} is made at compile time!  Or at the very latest, it
3366 is made at startup time.  @file{event-Xt.c} handles events for
3367 @emph{both} X and TTY frames; @file{event-tty.c} is only used when X
3368 support is not compiled into XEmacs.  The reason for this is that there
3369 is only one event loop in XEmacs: thus, it needs to be able to receive
3370 events from all different kinds of frames.
3371
3372
3373
3374 @example
3375 keymap.c
3376 keymap.h
3377 @end example
3378
3379 @file{keymap.c} and @file{keymap.h} define the @dfn{keymap} Lisp object
3380 type and associated methods and primitives. (Remember that keymaps are
3381 objects that associate event descriptions with functions to be called to
3382 ``execute'' those events; @code{dispatch-event} looks up events in the
3383 relevant keymaps.)
3384
3385
3386
3387 @example
3388 keyboard.c
3389 @end example
3390
3391 @file{keyboard.c} contains functions that implement the actual editor
3392 command loop -- i.e. the event loop that cyclically retrieves and
3393 dispatches events.  This code is also rather tricky, just like
3394 @file{event-stream.c}.
3395
3396
3397
3398 @example
3399 macros.c
3400 macros.h
3401 @end example
3402
3403 These two modules contain the basic code for defining keyboard macros.
3404 These functions don't actually do much; most of the code that handles keyboard
3405 macros is mixed in with the event-handling code in @file{event-stream.c}.
3406
3407
3408
3409 @example
3410 minibuf.c
3411 @end example
3412
3413 This contains some miscellaneous code related to the minibuffer (most of
3414 the minibuffer code was moved into Lisp by Richard Mlynarik).  This
3415 includes the primitives for completion (although filename completion is
3416 in @file{dired.c}), the lowest-level interface to the minibuffer (if the
3417 command loop were cleaned up, this too could be in Lisp), and code for
3418 dealing with the echo area (this, too, was mostly moved into Lisp, and
3419 the only code remaining is code to call out to Lisp or provide simple
3420 bootstrapping implementations early in temacs, before the echo-area Lisp
3421 code is loaded).
3422
3423
3424
3425 @node Modules for the Basic Displayable Lisp Objects
3426 @section Modules for the Basic Displayable Lisp Objects
3427
3428 @example
3429 device-ns.h
3430 device-stream.c
3431 device-stream.h
3432 device-tty.c
3433 device-tty.h
3434 device-x.c
3435 device-x.h
3436 device.c
3437 device.h
3438 @end example
3439
3440 These modules implement the @dfn{device} Lisp object type.  This
3441 abstracts a particular screen or connection on which frames are
3442 displayed.  As with Lisp objects, event interfaces, and other
3443 subsystems, the device code is separated into a generic component that
3444 contains a standardized interface (in the form of a set of methods) onto
3445 particular device types.
3446
3447 The device subsystem defines all the methods and provides method
3448 services for not only device operations but also for the frame, window,
3449 menubar, scrollbar, toolbar, and other displayable-object subsystems.
3450 The reason for this is that all of these subsystems have the same
3451 subtypes (X, TTY, NeXTstep, Microsoft Windows, etc.) as devices do.
3452
3453
3454
3455 @example
3456 frame-ns.h
3457 frame-tty.c
3458 frame-x.c
3459 frame-x.h
3460 frame.c
3461 frame.h
3462 @end example
3463
3464 Each device contains one or more frames in which objects (e.g. text) are
3465 displayed.  A frame corresponds to a window in the window system;
3466 usually this is a top-level window but it could potentially be one of a
3467 number of overlapping child windows within a top-level window, using the
3468 MDI (Multiple Document Interface) protocol in Microsoft Windows or a
3469 similar scheme.
3470
3471 The @file{frame-*} files implement the @dfn{frame} Lisp object type and
3472 provide the generic and device-type-specific operations on frames
3473 (e.g. raising, lowering, resizing, moving, etc.).
3474
3475
3476
3477 @example
3478 window.c
3479 window.h
3480 @end example
3481
3482 @cindex window (in Emacs)
3483 @cindex pane
3484 Each frame consists of one or more non-overlapping @dfn{windows} (better
3485 known as @dfn{panes} in standard window-system terminology) in which a
3486 buffer's text can be displayed.  Windows can also have scrollbars
3487 displayed around their edges.
3488
3489 @file{window.c} and @file{window.h} implement the @dfn{window} Lisp
3490 object type and provide code to manage windows.  Since windows have no
3491 associated resources in the window system (the window system knows only
3492 about the frame; no child windows or anything are used for XEmacs
3493 windows), there is no device-type-specific code here; all of that code
3494 is part of the redisplay mechanism or the code for particular object
3495 types such as scrollbars.
3496
3497
3498
3499 @node Modules for other Display-Related Lisp Objects
3500 @section Modules for other Display-Related Lisp Objects
3501
3502 @example
3503 faces.c
3504 faces.h
3505 @end example
3506
3507
3508
3509 @example
3510 bitmaps.h
3511 glyphs-ns.h
3512 glyphs-x.c
3513 glyphs-x.h
3514 glyphs.c
3515 glyphs.h
3516 @end example
3517
3518
3519
3520 @example
3521 objects-ns.h
3522 objects-tty.c
3523 objects-tty.h
3524 objects-x.c
3525 objects-x.h
3526 objects.c
3527 objects.h
3528 @end example
3529
3530
3531
3532 @example
3533 menubar-x.c
3534 menubar.c
3535 @end example
3536
3537
3538
3539 @example
3540 scrollbar-x.c
3541 scrollbar-x.h
3542 scrollbar.c
3543 scrollbar.h
3544 @end example
3545
3546
3547
3548 @example
3549 toolbar-x.c
3550 toolbar.c
3551 toolbar.h
3552 @end example
3553
3554
3555
3556 @example
3557 font-lock.c
3558 @end example
3559
3560 This file provides C support for syntax highlighting -- i.e.
3561 highlighting different syntactic constructs of a source file in
3562 different colors, for easy reading.  The C support is provided so that
3563 this is fast.
3564
3565
3566
3567 @example
3568 dgif_lib.c
3569 gif_err.c
3570 gif_lib.h
3571 gifalloc.c
3572 @end example
3573
3574 These modules decode GIF-format image files, for use with glyphs.
3575
3576
3577
3578 @node Modules for the Redisplay Mechanism
3579 @section Modules for the Redisplay Mechanism
3580
3581 @example
3582 redisplay-output.c
3583 redisplay-tty.c
3584 redisplay-x.c
3585 redisplay.c
3586 redisplay.h
3587 @end example
3588
3589 These files provide the redisplay mechanism.  As with many other
3590 subsystems in XEmacs, there is a clean separation between the general
3591 and device-specific support.
3592
3593 @file{redisplay.c} contains the bulk of the redisplay engine.  These
3594 functions update the redisplay structures (which describe how the screen
3595 is to appear) to reflect any changes made to the state of any
3596 displayable objects (buffer, frame, window, etc.) since the last time
3597 that redisplay was called.  These functions are highly optimized to
3598 avoid doing more work than necessary (since redisplay is called
3599 extremely often and is potentially a huge time sink), and depend heavily
3600 on notifications from the objects themselves that changes have occurred,
3601 so that redisplay doesn't explicitly have to check each possible object.
3602 The redisplay mechanism also contains a great deal of caching to further
3603 speed things up; some of this caching is contained within the various
3604 displayable objects.
3605
3606 @file{redisplay-output.c} goes through the redisplay structures and converts
3607 them into calls to device-specific methods to actually output the screen
3608 changes.
3609
3610 @file{redisplay-x.c} and @file{redisplay-tty.c} are two implementations
3611 of these redisplay output methods, for X frames and TTY frames,
3612 respectively.
3613
3614
3615
3616 @example
3617 indent.c
3618 @end example
3619
3620 This module contains various functions and Lisp primitives for
3621 converting between buffer positions and screen positions.  These
3622 functions call the redisplay mechanism to do most of the work, and then
3623 examine the redisplay structures to get the necessary information.  This
3624 module needs work.
3625
3626
3627
3628 @example
3629 termcap.c
3630 terminfo.c
3631 tparam.c
3632 @end example
3633
3634 These files contain functions for working with the termcap (BSD-style)
3635 and terminfo (System V style) databases of terminal capabilities and
3636 escape sequences, used when XEmacs is displaying in a TTY.
3637
3638
3639
3640 @example
3641 cm.c
3642 cm.h
3643 @end example
3644
3645 These files provide some miscellaneous TTY-output functions and should
3646 probably be merged into @file{redisplay-tty.c}.
3647
3648
3649
3650 @node Modules for Interfacing with the File System
3651 @section Modules for Interfacing with the File System
3652
3653 @example
3654 lstream.c
3655 lstream.h
3656 @end example
3657
3658 These modules implement the @dfn{stream} Lisp object type.  This is an
3659 internal-only Lisp object that implements a generic buffering stream.
3660 The idea is to provide a uniform interface onto all sources and sinks of
3661 data, including file descriptors, stdio streams, chunks of memory, Lisp
3662 buffers, Lisp strings, etc.  That way, I/O functions can be written to
3663 the stream interface and can transparently handle all possible sources
3664 and sinks.  (For example, the @code{read} function can read data from a
3665 file, a string, a buffer, or even a function that is called repeatedly
3666 to return data, without worrying about where the data is coming from or
3667 what-size chunks it is returned in.)
3668
3669 @cindex lstream
3670 Note that in the C code, streams are called @dfn{lstreams} (for ``Lisp
3671 streams'') to distinguish them from other kinds of streams, e.g. stdio
3672 streams and C++ I/O streams.
3673
3674 Similar to other subsystems in XEmacs, lstreams are separated into
3675 generic functions and a set of methods for the different types of
3676 lstreams.  @file{lstream.c} provides implementations of many different
3677 types of streams; others are provided, e.g., in @file{mule-coding.c}.
3678
3679
3680
3681 @example
3682 fileio.c
3683 @end example
3684
3685 This implements the basic primitives for interfacing with the file
3686 system.  This includes primitives for reading files into buffers,
3687 writing buffers into files, checking for the presence or accessibility
3688 of files, canonicalizing file names, etc.  Note that these primitives
3689 are usually not invoked directly by the user: There is a great deal of
3690 higher-level Lisp code that implements the user commands such as
3691 @code{find-file} and @code{save-buffer}.  This is similar to the
3692 distinction between the lower-level primitives in @file{editfns.c} and
3693 the higher-level user commands in @file{commands.c} and
3694 @file{simple.el}.
3695
3696
3697
3698 @example
3699 filelock.c
3700 @end example
3701
3702 This file provides functions for detecting clashes between different
3703 processes (e.g. XEmacs and some external process, or two different
3704 XEmacs processes) modifying the same file.  (XEmacs can optionally use
3705 the @file{lock/} subdirectory to provide a form of ``locking'' between
3706 different XEmacs processes.)  This module is also used by the low-level
3707 functions in @file{insdel.c} to ensure that, if the first modification
3708 is being made to a buffer whose corresponding file has been externally
3709 modified, the user is made aware of this so that the buffer can be
3710 synched up with the external changes if necessary.
3711
3712
3713 @example
3714 filemode.c
3715 @end example
3716
3717 This file provides some miscellaneous functions that construct a
3718 @samp{rwxr-xr-x}-type permissions string (as might appear in an
3719 @file{ls}-style directory listing) given the information returned by the
3720 @code{stat()} system call.
3721
3722
3723
3724 @example
3725 dired.c
3726 ndir.h
3727 @end example
3728
3729 These files implement the XEmacs interface to directory searching.  This
3730 includes a number of primitives for determining the files in a directory
3731 and for doing filename completion. (Remember that generic completion is
3732 handled by a different mechanism, in @file{minibuf.c}.)
3733
3734 @file{ndir.h} is a header file used for the directory-searching
3735 emulation functions provided in @file{sysdep.c} (see section J below),
3736 for systems that don't provide any directory-searching functions. (On
3737 those systems, directories can be read directly as files, and parsed.)
3738
3739
3740
3741 @example
3742 realpath.c
3743 @end example
3744
3745 This file provides an implementation of the @code{realpath()} function
3746 for expanding symbolic links, on systems that don't implement it or have
3747 a broken implementation.
3748
3749
3750
3751 @node Modules for Other Aspects of the Lisp Interpreter and Object System
3752 @section Modules for Other Aspects of the Lisp Interpreter and Object System
3753
3754 @example
3755 elhash.c
3756 elhash.h
3757 hash.c
3758 hash.h
3759 @end example
3760
3761 These files provide two implementations of hash tables.  Files
3762 @file{hash.c} and @file{hash.h} provide a generic C implementation of
3763 hash tables which can stand independently of XEmacs.  Files
3764 @file{elhash.c} and @file{elhash.h} provide a separate implementation of
3765 hash tables that can store only Lisp objects, and knows about Lispy
3766 things like garbage collection, and implement the @dfn{hash-table} Lisp
3767 object type.
3768
3769
3770 @example
3771 specifier.c
3772 specifier.h
3773 @end example
3774
3775 This module implements the @dfn{specifier} Lisp object type.  This is
3776 primarily used for displayable properties, and allows for values that
3777 are specific to a particular buffer, window, frame, device, or device
3778 class, as well as a default value existing.  This is used, for example,
3779 to control the height of the horizontal scrollbar or the appearance of
3780 the @code{default}, @code{bold}, or other faces.  The specifier object
3781 consists of a number of specifications, each of which maps from a
3782 buffer, window, etc. to a value.  The function @code{specifier-instance}
3783 looks up a value given a window (from which a buffer, frame, and device
3784 can be derived).
3785
3786
3787 @example
3788 chartab.c
3789 chartab.h
3790 casetab.c
3791 @end example
3792
3793 @file{chartab.c} and @file{chartab.h} implement the @dfn{char table}
3794 Lisp object type, which maps from characters or certain sorts of
3795 character ranges to Lisp objects.  The implementation of this object
3796 type is optimized for the internal representation of characters.  Char
3797 tables come in different types, which affect the allowed object types to
3798 which a character can be mapped and also dictate certain other
3799 properties of the char table.
3800
3801 @cindex case table
3802 @file{casetab.c} implements one sort of char table, the @dfn{case
3803 table}, which maps characters to other characters of possibly different
3804 case.  These are used by XEmacs to implement case-changing primitives
3805 and to do case-insensitive searching.
3806
3807
3808
3809 @example
3810 syntax.c
3811 syntax.h
3812 @end example
3813
3814 @cindex scanner
3815 This module implements @dfn{syntax tables}, another sort of char table
3816 that maps characters into syntax classes that define the syntax of these
3817 characters (e.g. a parenthesis belongs to a class of @samp{open}
3818 characters that have corresponding @samp{close} characters and can be
3819 nested).  This module also implements the Lisp @dfn{scanner}, a set of
3820 primitives for scanning over text based on syntax tables.  This is used,
3821 for example, to find the matching parenthesis in a command such as
3822 @code{forward-sexp}, and by @file{font-lock.c} to locate quoted strings,
3823 comments, etc.
3824
3825
3826
3827 @example
3828 casefiddle.c
3829 @end example
3830
3831 This module implements various Lisp primitives for upcasing, downcasing
3832 and capitalizing strings or regions of buffers.
3833
3834
3835
3836 @example
3837 rangetab.c
3838 @end example
3839
3840 This module implements the @dfn{range table} Lisp object type, which
3841 provides for a mapping from ranges of integers to arbitrary Lisp
3842 objects.
3843
3844
3845
3846 @example
3847 opaque.c
3848 opaque.h
3849 @end example
3850
3851 This module implements the @dfn{opaque} Lisp object type, an
3852 internal-only Lisp object that encapsulates an arbitrary block of memory
3853 so that it can be managed by the Lisp allocation system.  To create an
3854 opaque object, you call @code{make_opaque()}, passing a pointer to a
3855 block of memory.  An object is created that is big enough to hold the
3856 memory, which is copied into the object's storage.  The object will then
3857 stick around as long as you keep pointers to it, after which it will be
3858 automatically reclaimed.
3859
3860 @cindex mark method
3861 Opaque objects can also have an arbitrary @dfn{mark method} associated
3862 with them, in case the block of memory contains other Lisp objects that
3863 need to be marked for garbage-collection purposes. (If you need other
3864 object methods, such as a finalize method, you should just go ahead and
3865 create a new Lisp object type -- it's not hard.)
3866
3867
3868
3869 @example
3870 abbrev.c
3871 @end example
3872
3873 This function provides a few primitives for doing dynamic abbreviation
3874 expansion.  In XEmacs, most of the code for this has been moved into
3875 Lisp.  Some C code remains for speed and because the primitive
3876 @code{self-insert-command} (which is executed for all self-inserting
3877 characters) hooks into the abbrev mechanism. (@code{self-insert-command}
3878 is itself in C only for speed.)
3879
3880
3881
3882 @example
3883 doc.c
3884 @end example
3885
3886 This function provides primitives for retrieving the documentation
3887 strings of functions and variables.  These documentation strings contain
3888 certain special markers that get dynamically expanded (e.g. a
3889 reverse-lookup is performed on some named functions to retrieve their
3890 current key bindings).  Some documentation strings (in particular, for
3891 the built-in primitives and pre-loaded Lisp functions) are stored
3892 externally in a file @file{DOC} in the @file{lib-src/} directory and
3893 need to be fetched from that file. (Part of the build stage involves
3894 building this file, and another part involves constructing an index for
3895 this file and embedding it into the executable, so that the functions in
3896 @file{doc.c} do not have to search the entire @file{DOC} file to find
3897 the appropriate documentation string.)
3898
3899
3900
3901 @example
3902 md5.c
3903 @end example
3904
3905 This function provides a Lisp primitive that implements the MD5 secure
3906 hashing scheme, used to create a large hash value of a string of data such that
3907 the data cannot be derived from the hash value.  This is used for
3908 various security applications on the Internet.
3909
3910
3911
3912
3913 @node Modules for Interfacing with the Operating System
3914 @section Modules for Interfacing with the Operating System
3915
3916 @example
3917 callproc.c
3918 process.c
3919 process.h
3920 @end example
3921
3922 These modules allow XEmacs to spawn and communicate with subprocesses
3923 and network connections.
3924
3925 @cindex synchronous subprocesses
3926 @cindex subprocesses, synchronous
3927   @file{callproc.c} implements (through the @code{call-process}
3928 primitive) what are called @dfn{synchronous subprocesses}.  This means
3929 that XEmacs runs a program, waits till it's done, and retrieves its
3930 output.  A typical example might be calling the @file{ls} program to get
3931 a directory listing.
3932
3933 @cindex asynchronous subprocesses
3934 @cindex subprocesses, asynchronous
3935   @file{process.c} and @file{process.h} implement @dfn{asynchronous
3936 subprocesses}.  This means that XEmacs starts a program and then
3937 continues normally, not waiting for the process to finish.  Data can be
3938 sent to the process or retrieved from it as it's running.  This is used
3939 for the @code{shell} command (which provides a front end onto a shell
3940 program such as @file{csh}), the mail and news readers implemented in
3941 XEmacs, etc.  The result of calling @code{start-process} to start a
3942 subprocess is a process object, a particular kind of object used to
3943 communicate with the subprocess.  You can send data to the process by
3944 passing the process object and the data to @code{send-process}, and you
3945 can specify what happens to data retrieved from the process by setting
3946 properties of the process object. (When the process sends data, XEmacs
3947 receives a process event, which says that there is data ready.  When
3948 @code{dispatch-event} is called on this event, it reads the data from
3949 the process and does something with it, as specified by the process
3950 object's properties.  Typically, this means inserting the data into a
3951 buffer or calling a function.) Another property of the process object is
3952 called the @dfn{sentinel}, which is a function that is called when the
3953 process terminates.
3954
3955 @cindex network connections
3956   Process objects are also used for network connections (connections to a
3957 process running on another machine).  Network connections are started
3958 with @code{open-network-stream} but otherwise work just like
3959 subprocesses.
3960
3961
3962
3963 @example
3964 sysdep.c
3965 sysdep.h
3966 @end example
3967
3968   These modules implement most of the low-level, messy operating-system
3969 interface code.  This includes various device control (ioctl) operations
3970 for file descriptors, TTY's, pseudo-terminals, etc. (usually this stuff
3971 is fairly system-dependent; thus the name of this module), and emulation
3972 of standard library functions and system calls on systems that don't
3973 provide them or have broken versions.
3974
3975
3976
3977 @example
3978 sysdir.h
3979 sysfile.h
3980 sysfloat.h
3981 sysproc.h
3982 syspwd.h
3983 syssignal.h
3984 systime.h
3985 systty.h
3986 syswait.h
3987 @end example
3988
3989 These header files provide consistent interfaces onto system-dependent
3990 header files and system calls.  The idea is that, instead of including a
3991 standard header file like @file{<sys/param.h>} (which may or may not
3992 exist on various systems) or having to worry about whether all system
3993 provide a particular preprocessor constant, or having to deal with the
3994 four different paradigms for manipulating signals, you just include the
3995 appropriate @file{sys*.h} header file, which includes all the right
3996 system header files, defines and missing preprocessor constants,
3997 provides a uniform interface onto system calls, etc.
3998
3999 @file{sysdir.h} provides a uniform interface onto directory-querying
4000 functions. (In some cases, this is in conjunction with emulation
4001 functions in @file{sysdep.c}.)
4002
4003 @file{sysfile.h} includes all the necessary header files for standard
4004 system calls (e.g. @code{read()}), ensures that all necessary
4005 @code{open()} and @code{stat()} preprocessor constants are defined, and
4006 possibly (usually) substitutes sugared versions of @code{read()},
4007 @code{write()}, etc. that automatically restart interrupted I/O
4008 operations.
4009
4010 @file{sysfloat.h} includes the necessary header files for floating-point
4011 operations.
4012
4013 @file{sysproc.h} includes the necessary header files for calling
4014 @code{select()}, @code{fork()}, @code{execve()}, socket operations, and
4015 the like, and ensures that the @code{FD_*()} macros for descriptor-set
4016 manipulations are available.
4017
4018 @file{syspwd.h} includes the necessary header files for obtaining
4019 information from @file{/etc/passwd} (the functions are emulated under
4020 VMS).
4021
4022 @file{syssignal.h} includes the necessary header files for
4023 signal-handling and provides a uniform interface onto the different
4024 signal-handling and signal-blocking paradigms.
4025
4026 @file{systime.h} includes the necessary header files and provides
4027 uniform interfaces for retrieving the time of day, setting file
4028 access/modification times, getting the amount of time used by the XEmacs
4029 process, etc.
4030
4031 @file{systty.h} buffers against the infinitude of different ways of
4032 controlling TTY's.
4033
4034 @file{syswait.h} provides a uniform way of retrieving the exit status
4035 from a @code{wait()}ed-on process (some systems use a union, others use
4036 an int).
4037
4038
4039
4040 @example
4041 hpplay.c
4042 libsst.c
4043 libsst.h
4044 libst.h
4045 linuxplay.c
4046 nas.c
4047 sgiplay.c
4048 sound.c
4049 sunplay.c
4050 @end example
4051
4052 These files implement the ability to play various sounds on some types
4053 of computers.  You have to configure your XEmacs with sound support in
4054 order to get this capability.
4055
4056 @file{sound.c} provides the generic interface.  It implements various
4057 Lisp primitives and variables that let you specify which sounds should
4058 be played in certain conditions. (The conditions are identified by
4059 symbols, which are passed to @code{ding} to make a sound.  Various
4060 standard functions call this function at certain times; if sound support
4061 does not exist, a simple beep results.
4062
4063 @cindex native sound
4064 @cindex sound, native
4065 @file{sgiplay.c}, @file{sunplay.c}, @file{hpplay.c}, and
4066 @file{linuxplay.c} interface to the machine's speaker for various
4067 different kind of machines.  This is called @dfn{native} sound.
4068
4069 @cindex sound, network
4070 @cindex network sound
4071 @cindex NAS
4072 @file{nas.c} interfaces to a computer somewhere else on the network
4073 using the NAS (Network Audio Server) protocol, playing sounds on that
4074 machine.  This allows you to run XEmacs on a remote machine, with its
4075 display set to your local machine, and have the sounds be made on your
4076 local machine, provided that you have a NAS server running on your local
4077 machine.
4078
4079 @file{libsst.c}, @file{libsst.h}, and @file{libst.h} provide some
4080 additional functions for playing sound on a Sun SPARC but are not
4081 currently in use.
4082
4083
4084
4085 @example
4086 tooltalk.c
4087 tooltalk.h
4088 @end example
4089
4090 These two modules implement an interface to the ToolTalk protocol, which
4091 is an interprocess communication protocol implemented on some versions
4092 of Unix.  ToolTalk is a high-level protocol that allows processes to
4093 register themselves as providers of particular services; other processes
4094 can then request a service without knowing or caring exactly who is
4095 providing the service.  It is similar in spirit to the DDE protocol
4096 provided under Microsoft Windows.  ToolTalk is a part of the new CDE
4097 (Common Desktop Environment) specification and is used to connect the
4098 parts of the SPARCWorks development environment.
4099
4100
4101
4102 @example
4103 getloadavg.c
4104 @end example
4105
4106 This module provides the ability to retrieve the system's current load
4107 average. (The way to do this is highly system-specific, unfortunately,
4108 and requires a lot of special-case code.)
4109
4110
4111
4112 @example
4113 sunpro.c
4114 @end example
4115
4116 This module provides a small amount of code used internally at Sun to
4117 keep statistics on the usage of XEmacs.
4118
4119
4120
4121 @example
4122 broken-sun.h
4123 strcmp.c
4124 strcpy.c
4125 sunOS-fix.c
4126 @end example
4127
4128 These files provide replacement functions and prototypes to fix numerous
4129 bugs in early releases of SunOS 4.1.
4130
4131
4132
4133 @example
4134 hftctl.c
4135 @end example
4136
4137 This module provides some terminal-control code necessary on versions of
4138 AIX prior to 4.1.
4139
4140
4141
4142 @example
4143 msdos.c
4144 msdos.h
4145 @end example
4146
4147 These modules are used for MS-DOS support, which does not work in
4148 XEmacs.
4149
4150
4151
4152 @node Modules for Interfacing with X Windows
4153 @section Modules for Interfacing with X Windows
4154
4155 @example
4156 Emacs.ad.h
4157 @end example
4158
4159 A file generated from @file{Emacs.ad}, which contains XEmacs-supplied
4160 fallback resources (so that XEmacs has pretty defaults).
4161
4162
4163
4164 @example
4165 EmacsFrame.c
4166 EmacsFrame.h
4167 EmacsFrameP.h
4168 @end example
4169
4170 These modules implement an Xt widget class that encapsulates a frame.
4171 This is for ease in integrating with Xt.  The EmacsFrame widget covers
4172 the entire X window except for the menubar; the scrollbars are
4173 positioned on top of the EmacsFrame widget.
4174
4175 @strong{Warning:} Abandon hope, all ye who enter here.  This code took
4176 an ungodly amount of time to get right, and is likely to fall apart
4177 mercilessly at the slightest change.  Such is life under Xt.
4178
4179
4180
4181 @example
4182 EmacsManager.c
4183 EmacsManager.h
4184 EmacsManagerP.h
4185 @end example
4186
4187 These modules implement a simple Xt manager (i.e. composite) widget
4188 class that simply lets its children set whatever geometry they want.
4189 It's amazing that Xt doesn't provide this standardly, but on second
4190 thought, it makes sense, considering how amazingly broken Xt is.
4191
4192
4193 @example
4194 EmacsShell-sub.c
4195 EmacsShell.c
4196 EmacsShell.h
4197 EmacsShellP.h
4198 @end example
4199
4200 These modules implement two Xt widget classes that are subclasses of
4201 the TopLevelShell and TransientShell classes.  This is necessary to deal
4202 with more brokenness that Xt has sadistically thrust onto the backs of
4203 developers.
4204
4205
4206
4207 @example
4208 xgccache.c
4209 xgccache.h
4210 @end example
4211
4212 These modules provide functions for maintenance and caching of GC's
4213 (graphics contexts) under the X Window System.  This code is junky and
4214 needs to be rewritten.
4215
4216
4217
4218 @example
4219 xselect.c
4220 @end example
4221
4222 @cindex selections
4223   This module provides an interface to the X Window System's concept of
4224 @dfn{selections}, the standard way for X applications to communicate
4225 with each other.
4226
4227
4228
4229 @example
4230 xintrinsic.h
4231 xintrinsicp.h
4232 xmmanagerp.h
4233 xmprimitivep.h
4234 @end example
4235
4236 These header files are similar in spirit to the @file{sys*.h} files and buffer
4237 against different implementations of Xt and Motif.
4238
4239 @itemize @bullet
4240 @item
4241 @file{xintrinsic.h} should be included in place of @file{<Intrinsic.h>}.
4242 @item
4243 @file{xintrinsicp.h} should be included in place of @file{<IntrinsicP.h>}.
4244 @item
4245 @file{xmmanagerp.h} should be included in place of @file{<XmManagerP.h>}.
4246 @item
4247 @file{xmprimitivep.h} should be included in place of @file{<XmPrimitiveP.h>}.
4248 @end itemize
4249
4250
4251
4252 @example
4253 xmu.c
4254 xmu.h
4255 @end example
4256
4257 These files provide an emulation of the Xmu library for those systems
4258 (i.e. HPUX) that don't provide it as a standard part of X.
4259
4260
4261
4262 @example
4263 ExternalClient-Xlib.c
4264 ExternalClient.c
4265 ExternalClient.h
4266 ExternalClientP.h
4267 ExternalShell.c
4268 ExternalShell.h
4269 ExternalShellP.h
4270 extw-Xlib.c
4271 extw-Xlib.h
4272 extw-Xt.c
4273 extw-Xt.h
4274 @end example
4275
4276 @cindex external widget
4277   These files provide the @dfn{external widget} interface, which allows an
4278 XEmacs frame to appear as a widget in another application.  To do this,
4279 you have to configure with @samp{--external-widget}.
4280
4281 @file{ExternalShell*} provides the server (XEmacs) side of the
4282 connection.
4283
4284 @file{ExternalClient*} provides the client (other application) side of
4285 the connection.  These files are not compiled into XEmacs but are
4286 compiled into libraries that are then linked into your application.
4287
4288 @file{extw-*} is common code that is used for both the client and server.
4289
4290 Don't touch this code; something is liable to break if you do.
4291
4292
4293
4294 @node Modules for Internationalization
4295 @section Modules for Internationalization
4296
4297 @example
4298 mule-canna.c
4299 mule-ccl.c
4300 mule-charset.c
4301 mule-charset.h
4302 mule-coding.c
4303 mule-coding.h
4304 mule-mcpath.c
4305 mule-mcpath.h
4306 mule-wnnfns.c
4307 mule.c
4308 @end example
4309
4310 These files implement the MULE (Asian-language) support.  Note that MULE
4311 actually provides a general interface for all sorts of languages, not
4312 just Asian languages (although they are generally the most complicated
4313 to support).  This code is still in beta.
4314
4315 @file{mule-charset.*} and @file{mule-coding.*} provide the heart of the
4316 XEmacs MULE support.  @file{mule-charset.*} implements the @dfn{charset}
4317 Lisp object type, which encapsulates a character set (an ordered one- or
4318 two-dimensional set of characters, such as US ASCII or JISX0208 Japanese
4319 Kanji).
4320
4321 @file{mule-coding.*} implements the @dfn{coding-system} Lisp object
4322 type, which encapsulates a method of converting between different
4323 encodings.  An encoding is a representation of a stream of characters,
4324 possibly from multiple character sets, using a stream of bytes or words,
4325 and defines (e.g.) which escape sequences are used to specify particular
4326 character sets, how the indices for a character are converted into bytes
4327 (sometimes this involves setting the high bit; sometimes complicated
4328 rearranging of the values takes place, as in the Shift-JIS encoding),
4329 etc.
4330
4331 @file{mule-ccl.c} provides the CCL (Code Conversion Language)
4332 interpreter.  CCL is similar in spirit to Lisp byte code and is used to
4333 implement converters for custom encodings.
4334
4335 @file{mule-canna.c} and @file{mule-wnnfns.c} implement interfaces to
4336 external programs used to implement the Canna and WNN input methods,
4337 respectively.  This is currently in beta.
4338
4339 @file{mule-mcpath.c} provides some functions to allow for pathnames
4340 containing extended characters.  This code is fragmentary, obsolete, and
4341 completely non-working.  Instead, @var{pathname-coding-system} is used
4342 to specify conversions of names of files and directories.  The standard
4343 C I/O functions like @samp{open()} are wrapped so that conversion occurs
4344 automatically.
4345
4346 @file{mule.c} provides a few miscellaneous things that should probably
4347 be elsewhere.
4348
4349
4350
4351 @example
4352 intl.c
4353 @end example
4354
4355 This provides some miscellaneous internationalization code for
4356 implementing message translation and interfacing to the Ximp input
4357 method.  None of this code is currently working.
4358
4359
4360
4361 @example
4362 iso-wide.h
4363 @end example
4364
4365 This contains leftover code from an earlier implementation of
4366 Asian-language support, and is not currently used.
4367
4368
4369
4370
4371 @node Allocation of Objects in XEmacs Lisp, Events and the Event Loop, A Summary of the Various XEmacs Modules, Top
4372 @chapter Allocation of Objects in XEmacs Lisp
4373
4374 @menu
4375 * Introduction to Allocation::
4376 * Garbage Collection::
4377 * GCPROing::
4378 * Garbage Collection - Step by Step::
4379 * Integers and Characters::
4380 * Allocation from Frob Blocks::
4381 * lrecords::
4382 * Low-level allocation::
4383 * Pure Space::
4384 * Cons::
4385 * Vector::
4386 * Bit Vector::
4387 * Symbol::
4388 * Marker::
4389 * String::
4390 * Compiled Function::
4391 @end menu
4392
4393 @node Introduction to Allocation
4394 @section Introduction to Allocation
4395
4396   Emacs Lisp, like all Lisps, has garbage collection.  This means that
4397 the programmer never has to explicitly free (destroy) an object; it
4398 happens automatically when the object becomes inaccessible.  Most
4399 experts agree that garbage collection is a necessity in a modern,
4400 high-level language.  Its omission from C stems from the fact that C was
4401 originally designed to be a nice abstract layer on top of assembly
4402 language, for writing kernels and basic system utilities rather than
4403 large applications.
4404
4405   Lisp objects can be created by any of a number of Lisp primitives.
4406 Most object types have one or a small number of basic primitives
4407 for creating objects.  For conses, the basic primitive is @code{cons};
4408 for vectors, the primitives are @code{make-vector} and @code{vector}; for
4409 symbols, the primitives are @code{make-symbol} and @code{intern}; etc.
4410 Some Lisp objects, especially those that are primarily used internally,
4411 have no corresponding Lisp primitives.  Every Lisp object, though,
4412 has at least one C primitive for creating it.
4413
4414   Recall from section (VII) that a Lisp object, as stored in a 32-bit
4415 or 64-bit word, has a mark bit, a few tag bits, and a ``value'' that
4416 occupies the remainder of the bits.  We can separate the different
4417 Lisp object types into four broad categories:
4418
4419 @itemize @bullet
4420 @item
4421 (a) Those for whom the value directly represents the contents of the
4422 Lisp object.  Only two types are in this category: integers and
4423 characters.  No special allocation or garbage collection is necessary
4424 for such objects.  Lisp objects of these types do not need to be
4425 @code{GCPRO}ed.
4426 @end itemize
4427
4428   In the remaining three categories, the value is a pointer to a
4429 structure.
4430
4431 @itemize @bullet
4432 @item
4433 @cindex frob block
4434 (b) Those for whom the tag directly specifies the type.  Recall that
4435 there are only three tag bits; this means that at most five types can be
4436 specified this way.  The most commonly-used types are stored in this
4437 format; this includes conses, strings, vectors, and sometimes symbols.
4438 With the exception of vectors, objects in this category are allocated in
4439 @dfn{frob blocks}, i.e. large blocks of memory that are subdivided into
4440 individual objects.  This saves a lot on malloc overhead, since there
4441 are typically quite a lot of these objects around, and the objects are
4442 small.  (A cons, for example, occupies 8 bytes on 32-bit machines -- 4
4443 bytes for each of the two objects it contains.) Vectors are individually
4444 @code{malloc()}ed since they are of variable size.  (It would be
4445 possible, and desirable, to allocate vectors of certain small sizes out
4446 of frob blocks, but it isn't currently done.) Strings are handled
4447 specially: Each string is allocated in two parts, a fixed size structure
4448 containing a length and a data pointer, and the actual data of the
4449 string.  The former structure is allocated in frob blocks as usual, and
4450 the latter data is stored in @dfn{string chars blocks} and is relocated
4451 during garbage collection to eliminate holes.
4452 @end itemize
4453
4454   In the remaining two categories, the type is stored in the object
4455 itself.  The tag for all such objects is the generic @dfn{lrecord}
4456 (Lisp_Record) tag.  The first four bytes (or eight, for 64-bit machines)
4457 of the object's structure are a pointer to a structure that describes
4458 the object's type, which includes method pointers and a pointer to a
4459 string naming the type.  Note that it's possible to save some space by
4460 using a one- or two-byte tag, rather than a four- or eight-byte pointer
4461 to store the type, but it's not clear it's worth making the change.
4462
4463 @itemize @bullet
4464 @item
4465 (c) Those lrecords that are allocated in frob blocks (see above).  This
4466 includes the objects that are most common and relatively small, and
4467 includes floats, compiled functions, symbols (when not in category (b)),
4468 extents, events, and markers.  With the cleanup of frob blocks done in
4469 19.12, it's not terribly hard to add more objects to this category, but
4470 it's a bit trickier than adding an object type to type (d) (esp. if the
4471 object needs a finalization method), and is not likely to save much
4472 space unless the object is small and there are many of them. (In fact,
4473 if there are very few of them, it might actually waste space.)
4474 @item
4475 (d) Those lrecords that are individually @code{malloc()}ed.  These are
4476 called @dfn{lcrecords}.  All other types are in this category.  Adding a
4477 new type to this category is comparatively easy, and all types added
4478 since 19.8 (when the current allocation scheme was devised, by Richard
4479 Mlynarik), with the exception of the character type, have been in this
4480 category.
4481 @end itemize
4482
4483   Note that bit vectors are a bit of a special case.  They are
4484 simple lrecords as in category (c), but are individually @code{malloc()}ed
4485 like vectors.  You can basically view them as exactly like vectors
4486 except that their type is stored in lrecord fashion rather than
4487 in directly-tagged fashion.
4488
4489   Note that FSF Emacs redesigned their object system in 19.29 to follow
4490 a similar scheme.  However, given RMS's expressed dislike for data
4491 abstraction, the FSF scheme is not nearly as clean or as easy to
4492 extend. (FSF calls items of type (c) @code{Lisp_Misc} and items of type
4493 (d) @code{Lisp_Vectorlike}, with separate tags for each, although
4494 @code{Lisp_Vectorlike} is also used for vectors.)
4495
4496 @node Garbage Collection
4497 @section Garbage Collection
4498 @cindex garbage collection
4499
4500 @cindex mark and sweep
4501   Garbage collection is simple in theory but tricky to implement.
4502 Emacs Lisp uses the oldest garbage collection method, called
4503 @dfn{mark and sweep}.  Garbage collection begins by starting with
4504 all accessible locations (i.e. all variables and other slots where
4505 Lisp objects might occur) and recursively traversing all objects
4506 accessible from those slots, marking each one that is found.
4507 We then go through all of memory and free each object that is
4508 not marked, and unmarking each object that is marked.  Note
4509 that ``all of memory'' means all currently allocated objects.
4510 Traversing all these objects means traversing all frob blocks,
4511 all vectors (which are chained in one big list), and all
4512 lcrecords (which are likewise chained).
4513
4514   Note that, when an object is marked, the mark has to occur
4515 inside of the object's structure, rather than in the 32-bit
4516 @code{Lisp_Object} holding the object's pointer; i.e. you can't just
4517 set the pointer's mark bit.  This is because there may be many
4518 pointers to the same object.  This means that the method of
4519 marking an object can differ depending on the type.  The
4520 different marking methods are approximately as follows:
4521
4522 @enumerate
4523 @item
4524 For conses, the mark bit of the car is set.
4525 @item
4526 For strings, the mark bit of the string's plist is set.
4527 @item
4528 For symbols when not lrecords, the mark bit of the
4529 symbol's plist is set.
4530 @item
4531 For vectors, the length is negated after adding 1.
4532 @item
4533 For lrecords, the pointer to the structure describing
4534 the type is changed (see below).
4535 @item
4536 Integers and characters do not need to be marked, since
4537 no allocation occurs for them.
4538 @end enumerate
4539
4540   The details of this are in the @code{mark_object()} function.
4541
4542   Note that any code that operates during garbage collection has
4543 to be especially careful because of the fact that some objects
4544 may be marked and as such may not look like they normally do.
4545 In particular:
4546
4547 @itemize @bullet
4548 Some object pointers may have their mark bit set.  This will make
4549 @code{FOOBARP()} predicates fail.  Use @code{GC_FOOBARP()} to deal with
4550 this.
4551 @item
4552 Even if you clear the mark bit, @code{FOOBARP()} will still fail
4553 for lrecords because the implementation pointer has been
4554 changed (see below).  @code{GC_FOOBARP()} will correctly deal with
4555 this.
4556 @item
4557 Vectors have their size field munged, so anything that
4558 looks at this field will fail.
4559 @item
4560 Note that @code{XFOOBAR()} macros @emph{will} work correctly on object
4561 pointers with their mark bit set, because the logical shift operations
4562 that remove the tag also remove the mark bit.
4563 @end itemize
4564
4565   Finally, note that garbage collection can be invoked explicitly
4566 by calling @code{garbage-collect} but is also called automatically
4567 by @code{eval}, once a certain amount of memory has been allocated
4568 since the last garbage collection (according to @code{gc-cons-threshold}).
4569
4570 @node GCPROing
4571 @section @code{GCPRO}ing
4572
4573 @code{GCPRO}ing is one of the ugliest and trickiest parts of Emacs
4574 internals.  The basic idea is that whenever garbage collection
4575 occurs, all in-use objects must be reachable somehow or
4576 other from one of the roots of accessibility.  The roots
4577 of accessibility are:
4578
4579 @enumerate
4580 @item
4581 All objects that have been @code{staticpro()}d.  This is used for
4582 any global C variables that hold Lisp objects.  A call to
4583 @code{staticpro()} happens implicitly as a result of any symbols
4584 declared with @code{defsymbol()} and any variables declared with
4585 @code{DEFVAR_FOO()}.  You need to explicitly call @code{staticpro()}
4586 (in the @code{vars_of_foo()} method of a module) for other global
4587 C variables holding Lisp objects. (This typically includes
4588 internal lists and such things.)
4589
4590 Note that @code{obarray} is one of the @code{staticpro()}d things.
4591 Therefore, all functions and variables get marked through this.
4592 @item
4593 Any shadowed bindings that are sitting on the @code{specpdl} stack.
4594 @item
4595 Any objects sitting in currently active (Lisp) stack frames,
4596 catches, and condition cases.
4597 @item
4598 A couple of special-case places where active objects are
4599 located.
4600 @item
4601 Anything currently marked with @code{GCPRO}.
4602 @end enumerate
4603
4604   Marking with @code{GCPRO} is necessary because some C functions (quite
4605 a lot, in fact), allocate objects during their operation.  Quite
4606 frequently, there will be no other pointer to the object while the
4607 function is running, and if a garbage collection occurs and the object
4608 needs to be referenced again, bad things will happen.  The solution is
4609 to mark those objects with @code{GCPRO}.  Unfortunately this is easy to
4610 forget, and there is basically no way around this problem.  Here are
4611 some rules, though:
4612
4613 @enumerate
4614 @item
4615 For every @code{GCPRO@var{n}}, there have to be declarations of
4616 @code{struct gcpro gcpro1, gcpro2}, etc.
4617
4618 @item
4619 You @emph{must} @code{UNGCPRO} anything that's @code{GCPRO}ed, and you
4620 @emph{must not} @code{UNGCPRO} if you haven't @code{GCPRO}ed.  Getting
4621 either of these wrong will lead to crashes, often in completely random
4622 places unrelated to where the problem lies.
4623
4624 @item
4625 The way this actually works is that all currently active @code{GCPRO}s
4626 are chained through the @code{struct gcpro} local variables, with the
4627 variable @samp{gcprolist} pointing to the head of the list and the nth
4628 local @code{gcpro} variable pointing to the first @code{gcpro} variable
4629 in the next enclosing stack frame.  Each @code{GCPRO}ed thing is an
4630 lvalue, and the @code{struct gcpro} local variable contains a pointer to
4631 this lvalue.  This is why things will mess up badly if you don't pair up
4632 the @code{GCPRO}s and @code{UNGCPRO}s -- you will end up with
4633 @code{gcprolist}s containing pointers to @code{struct gcpro}s or local
4634 @code{Lisp_Object} variables in no-longer-active stack frames.
4635
4636 @item
4637 It is actually possible for a single @code{struct gcpro} to
4638 protect a contiguous array of any number of values, rather than
4639 just a single lvalue.  To effect this, call @code{GCPRO@var{n}} as usual on
4640 the first object in the array and then set @code{gcpro@var{n}.nvars}.
4641
4642 @item
4643 @strong{Strings are relocated.}  What this means in practice is that the
4644 pointer obtained using @code{XSTRING_DATA()} is liable to change at any
4645 time, and you should never keep it around past any function call, or
4646 pass it as an argument to any function that might cause a garbage
4647 collection.  This is why a number of functions accept either a
4648 ``non-relocatable'' @code{char *} pointer or a relocatable Lisp string,
4649 and only access the Lisp string's data at the very last minute.  In some
4650 cases, you may end up having to @code{alloca()} some space and copy the
4651 string's data into it.
4652
4653 @item
4654 By convention, if you have to nest @code{GCPRO}'s, use @code{NGCPRO@var{n}}
4655 (along with @code{struct gcpro ngcpro1, ngcpro2}, etc.), @code{NNGCPRO@var{n}},
4656 etc.  This avoids compiler warnings about shadowed locals.
4657
4658 @item
4659 It is @emph{always} better to err on the side of extra @code{GCPRO}s
4660 rather than too few.  The extra cycles spent on this are
4661 almost never going to make a whit of difference in the
4662 speed of anything.
4663
4664 @item
4665 The general rule to follow is that caller, not callee, @code{GCPRO}s.
4666 That is, you should not have to explicitly @code{GCPRO} any Lisp objects
4667 that are passed in as parameters.
4668
4669 One exception from this rule is if you ever plan to change the parameter
4670 value, and store a new object in it.  In that case, you @emph{must}
4671 @code{GCPRO} the parameter, because otherwise the new object will not be
4672 protected.
4673
4674 So, if you create any Lisp objects (remember, this happens in all sorts
4675 of circumstances, e.g. with @code{Fcons()}, etc.), you are responsible
4676 for @code{GCPRO}ing them, unless you are @emph{absolutely sure} that
4677 there's no possibility that a garbage-collection can occur while you
4678 need to use the object.  Even then, consider @code{GCPRO}ing.
4679
4680 @item
4681 A garbage collection can occur whenever anything calls @code{Feval}, or
4682 whenever a QUIT can occur where execution can continue past
4683 this. (Remember, this is almost anywhere.)
4684
4685 @item
4686 If you have the @emph{least smidgeon of doubt} about whether
4687 you need to @code{GCPRO}, you should @code{GCPRO}.
4688
4689 @item
4690 Beware of @code{GCPRO}ing something that is uninitialized.  If you have
4691 any shade of doubt about this, initialize all your variables to @code{Qnil}.
4692
4693 @item
4694 Be careful of traps, like calling @code{Fcons()} in the argument to
4695 another function.  By the ``caller protects'' law, you should be
4696 @code{GCPRO}ing the newly-created cons, but you aren't.  A certain
4697 number of functions that are commonly called on freshly created stuff
4698 (e.g. @code{nconc2()}, @code{Fsignal()}), break the ``caller protects''
4699 law and go ahead and @code{GCPRO} their arguments so as to simplify
4700 things, but make sure and check if it's OK whenever doing something like
4701 this.
4702
4703 @item
4704 Once again, remember to @code{GCPRO}!  Bugs resulting from insufficient
4705 @code{GCPRO}ing are intermittent and extremely difficult to track down,
4706 often showing up in crashes inside of @code{garbage-collect} or in
4707 weirdly corrupted objects or even in incorrect values in a totally
4708 different section of code.
4709 @end enumerate
4710
4711 @cindex garbage collection, conservative
4712 @cindex conservative garbage collection
4713   Given the extremely error-prone nature of the @code{GCPRO} scheme, and
4714 the difficulties in tracking down, it should be considered a deficiency
4715 in the XEmacs code.  A solution to this problem would involve
4716 implementing so-called @dfn{conservative} garbage collection for the C
4717 stack.  That involves looking through all of stack memory and treating
4718 anything that looks like a reference to an object as a reference.  This
4719 will result in a few objects not getting collected when they should, but
4720 it obviates the need for @code{GCPRO}ing, and allows garbage collection
4721 to happen at any point at all, such as during object allocation.
4722
4723 @node Garbage Collection - Step by Step
4724 @section Garbage Collection - Step by Step
4725 @cindex garbage collection step by step
4726
4727 @menu
4728 * Invocation::
4729 * garbage_collect_1::
4730 * mark_object::
4731 * gc_sweep::
4732 * sweep_lcrecords_1::
4733 * compact_string_chars::
4734 * sweep_strings::
4735 * sweep_bit_vectors_1::
4736 @end menu
4737
4738 @node Invocation
4739 @subsection Invocation
4740 @cindex garbage collection, invocation
4741
4742 The first thing that anyone should know about garbage collection is:
4743 when and how the garbage collector is invoked. One might think that this 
4744 could happen every time new memory is allocated, e.g. new objects are
4745 created, but this is @emph{not} the case. Instead, we have the following
4746 situation:
4747
4748 The entry point of any process of garbage collection is an invocation
4749 of the function @code{garbage_collect_1} in file @code{alloc.c}. The
4750 invocation can occur @emph{explicitly} by calling the function
4751 @code{Fgarbage_collect} (in addition this function provides information
4752 about the freed memory), or can occur @emph{implicitly} in four different 
4753 situations:
4754 @enumerate
4755 @item
4756 In function @code{main_1} in file @code{emacs.c}. This function is called
4757 at each startup of xemacs. The garbage collection is invoked after all
4758 initial creations are completed, but only if a special internal error
4759 checking-constant @code{ERROR_CHECK_GC} is defined.
4760 @item
4761 In function @code{disksave_object_finalization} in file
4762 @code{alloc.c}. The only purpose of this function is to clear the
4763 objects from memory which need not be stored with xemacs when we dump out 
4764 an executable. This is only done by @code{Fdump_emacs} or by
4765 @code{Fdump_emacs_data} respectively (both in @code{emacs.c}). The
4766 actual clearing is accomplished by making these objects unreachable and
4767 starting a garbage collection. The function is only used while building
4768 xemacs.
4769 @item
4770 In function @code{Feval / eval} in file @code{eval.c}. Each time the
4771 well known and often used function eval is called to evaluate a form,
4772 one of the first things that could happen, is a potential call of
4773 @code{garbage_collect_1}. There exist three global variables,
4774 @code{consing_since_gc} (counts the created cons-cells since the last
4775 garbage collection), @code{gc_cons_threshold} (a specified threshold
4776 after which a garbage collection occurs) and @code{always_gc}. If
4777 @code{always_gc} is set or if the threshold is exceeded, the garbage
4778 collection will start.
4779 @item
4780 In function @code{Ffuncall / funcall} in file @code{eval.c}. This
4781 function evaluates calls of elisp functions and works according to
4782 @code{Feval}.
4783 @end enumerate
4784
4785 The upshot is that garbage collection can basically occur everywhere
4786 @code{Feval}, respectively @code{Ffuncall}, is used - either directly or
4787 through another function. Since calls to these two functions are
4788 hidden in various other functions, many calls to
4789 @code{garabge_collect_1} are not obviously foreseeable, and therefore
4790 unexpected. Instances where they are used that are worth remembering are
4791 various elisp commands, as for example @code{or},
4792 @code{and}, @code{if}, @code{cond}, @code{while}, @code{setq}, etc.,
4793 miscellaneous @code{gui_item_...} functions, everything related to
4794 @code{eval} (@code{Feval_buffer}, @code{call0}, ...) and inside
4795 @code{Fsignal}. The latter is used to handle signals, as for example the
4796 ones raised by every @code{QUITE}-macro triggered after pressing Ctrl-g.
4797
4798 @node garbage_collect_1
4799 @subsection @code{garbage_collect_1}
4800 @cindex @code{garbage_collect_1}
4801
4802 We can now describe exactly what happens after the invocation takes
4803 place.
4804 @enumerate
4805 @item
4806 There are several cases in which the garbage collector is left immediately: 
4807 when we are already garbage collecting (@code{gc_in_progress}), when
4808 the garbage collection is somehow forbidden
4809 (@code{gc_currently_forbidden}), when we are currently displaying something
4810 (@code{in_display}) or when we are preparing for the armageddon of the
4811 whole system (@code{preparing_for_armageddon}).
4812 @item
4813 Next the correct frame in which to put
4814 all the output occurring during garbage collecting is determined. In
4815 order to be able to restore the old display's state after displaying the
4816 message, some data about the current cursor position has to be
4817 saved. The variables @code{pre_gc_curser} and @code{cursor_changed} take
4818 care of that.
4819 @item
4820 The state of @code{gc_currently_forbidden} must be restored after
4821 the garbage collection, no matter what happens during the process. We
4822 accomplish this by @code{record_unwind_protect}ing the suitable function
4823 @code{restore_gc_inhibit} together with the current value of
4824 @code{gc_currently_forbidden}. 
4825 @item
4826 If we are concurrently running an interactive xemacs session, the next step
4827 is simply to show the garbage collector's cursor/message.
4828 @item
4829 The following steps are the intrinsic steps of the garbage collector,
4830 therefore @code{gc_in_progress} is set.
4831 @item
4832 For debugging purposes, it is possible to copy the current C stack
4833 frame. However, this seems to be a currently unused feature.
4834 @item
4835 Before actually starting to go over all live objects, references to
4836 objects that are no longer used are pruned. We only have to do this for events
4837 (@code{clear_event_resource}) and for specifiers
4838 (@code{cleanup_specifiers}). 
4839 @item
4840 Now the mark phase begins and marks all accessible elements. In order to
4841 start from
4842 all slots that serve as roots of accessibility, the function
4843 @code{mark_object} is called for each root individually to go out from
4844 there to mark all reachable objects. All roots that are traversed are
4845 shown in their processed order:
4846 @itemize @bullet
4847 @item
4848 all constant symbols and static variables that are registered via
4849 @code{staticpro}@ in the array @code{staticvec}.
4850 @xref{Adding Global Lisp Variables}. 
4851 @item
4852 all Lisp objects that are created in C functions and that must be
4853 protected from freeing them. They are registered in the global
4854 list @code{gcprolist}.
4855 @xref{GCPROing}.
4856 @item 
4857 all local variables (i.e. their name fields @code{symbol} and old
4858 values @code{old_values}) that are bound during the evaluation by the Lisp
4859 engine. They are stored in @code{specbinding} structs pushed on a stack
4860 called @code{specpdl}.
4861 @xref{Dynamic Binding; The specbinding Stack; Unwind-Protects}.
4862 @item
4863 all catch blocks that the Lisp engine encounters during the evaluation
4864 cause the creation of structs @code{catchtag} inserted in the list
4865 @code{catchlist}. Their tag (@code{tag}) and value (@code{val} fields
4866 are freshly created objects and therefore have to be marked.
4867 @xref{Catch and Throw}.
4868 @item
4869 every function application pushes new structs @code{backtrace} 
4870 on the call stack of the Lisp engine (@code{backtrace_list}). The unique 
4871 parts that have to be marked are the fields for each function
4872 (@code{function}) and all their arguments (@code{args}).
4873 @xref{Evaluation}.
4874 @item
4875 all objects that are used by the redisplay engine that must not be freed 
4876 are marked by a special function called @code{mark_redisplay} (in
4877 @code{redisplay.c}).
4878 @item
4879 all objects created for profiling purposes are allocated by C functions
4880 instead of using the lisp allocation mechanisms. In order to receive the
4881 right ones during the sweep phase, they also have to be marked
4882 manually. That is done by the function @code{mark_profiling_info}
4883 @end itemize
4884 @item
4885 Hash tables in Xemacs belong to a kind of special objects that
4886 make use of a concept often called 'weak pointers'.
4887 To make a long story short, these kind of pointers are not followed
4888 during the estimation of the live objects during garbage collection.
4889 Any object referenced only by weak pointers is collected
4890 anyway, and the reference to it is cleared. In hash tables there are
4891 different usage patterns of them, manifesting in different types of hash
4892 tables, namely 'non-weak', 'weak', 'key-weak' and 'value-weak'
4893 (internally also 'key-car-weak' and 'value-car-weak') hash tables, each 
4894 clearing entries depending on different conditions. More information can 
4895 be found in the documentation to the function @code{make-hash-table}.
4896
4897 Because there are complicated dependency rules about when and what to
4898 mark while processing weak hash tables, the standard @code{marker}
4899 method is only active if it is marking non-weak hash tables. As soon as
4900 a weak component is in the table, the hash table entries are ignored
4901 while marking. Instead their marking is done each separately by the
4902 function @code{finish_marking_weak_hash_tables}. This function iterates
4903 over each hash table entry @code{hentries} for each weak hash table in
4904 @code{Vall_weak_hash_tables}. Depending on the type of a table, the
4905 appropriate action is performed. 
4906 If a table is acting as @code{HASH_TABLE_KEY_WEAK}, and a key already marked,
4907 everything reachable from the @code{value} component is marked. If it is 
4908 acting as a @code{HASH_TABLE_VALUE_WEAK} and the value component is
4909 already marked, the marking starts beginning only from the 
4910 @code{key} component.
4911 If it is a @code{HASH_TABLE_KEY_CAR_WEAK} and the car 
4912 of the key entry is already marked, we mark both the @code{key} and
4913 @code{value} components.
4914 Finally, if the table is of the type @code{HASH_TABLE_VALUE_CAR_WEAK}
4915 and the car of the value components is already marked, again both the
4916 @code{key} and the @code{value} components get marked.
4917
4918 Again, there are lists with comparable properties called weak
4919 lists. There exist different peculiarities of their types called
4920 @code{simple}, @code{assoc}, @code{key-assoc} and
4921 @code{value-assoc}. You can find further details about them in the
4922 description to the function @code{make-weak-list}. The scheme of their
4923 marking is similar: all weak lists are listed in @code{Qall_weak_lists}, 
4924 therefore we iterate over them. The marking is advanced until we hit an
4925 already marked pair. Then we know that during a former run all 
4926 the rest has been marked completely. Again, depending on the special
4927 type of the weak list, our jobs differ. If it is a @code{WEAK_LIST_SIMPLE}
4928 and the elem is marked, we mark the @code{cons} part. If it is a
4929 @code{WEAK_LIST_ASSOC} and not a pair or a pair with both marked car and
4930 cdr, we mark the @code{cons} and the @code{elem}. If it is a
4931 @code{WEAK_LIST_KEY_ASSOC} and not a pair or a pair with a marked car of
4932 the elem, we mark the @code{cons} and the @code{elem}. Finally, if it is
4933 a @code{WEAK_LIST_VALUE_ASSOC} and not a pair or a pair with a marked
4934 cdr of the elem, we mark both the @code{cons} and the @code{elem}.
4935
4936 Since, by marking objects in reach from weak hash tables and weak lists,
4937 other objects could get marked, this perhaps implies further marking of
4938 other weak objects, both finishing functions are redone as long as 
4939 yet unmarked objects get freshly marked.
4940
4941 @item
4942 After completing the special marking for the weak hash tables and for the weak
4943 lists, all entries that point to objects that are going to be swept in
4944 the further process are useless, and therefore have to be removed from
4945 the table or the list.
4946
4947 The function @code{prune_weak_hash_tables} does the job for weak hash
4948 tables. Totally unmarked hash tables are removed from the list
4949 @code{Vall_weak_hash_tables}. The other ones are treated more carefully
4950 by scanning over all entries and removing one as soon as one of 
4951 the components @code{key} and @code{value} is unmarked.
4952
4953 The same idea applies to the weak lists. It is accomplished by
4954 @code{prune_weak_lists}: An unmarked list is pruned from
4955 @code{Vall_weak_lists} immediately. A marked list is treated more
4956 carefully by going over it and removing just the unmarked pairs.
4957
4958 @item
4959 The function @code{prune_specifiers} checks all listed specifiers held
4960 in @code{Vall_speficiers} and removes the ones from the lists that are 
4961 unmarked.
4962
4963 @item
4964 All syntax tables are stored in a list called
4965 @code{Vall_syntax_tables}. The function @code{prune_syntax_tables} walks 
4966 through it and unlinks the tables that are unmarked.
4967
4968 @item
4969 Next, we will attack the complete sweeping - the function
4970 @code{gc_sweep} which holds the predominance.
4971 @item
4972 First, all the variables with respect to garbage collection are
4973 reset. @code{consing_since_gc} - the counter of the created cells since 
4974 the last garbage collection - is set back to 0, and
4975 @code{gc_in_progress} is not @code{true} anymore.
4976 @item
4977 In case the session is interactive, the displayed cursor and message are 
4978 removed again.
4979 @item
4980 The state of @code{gc_inhibit} is restored to the former value by
4981 unwinding the stack.
4982 @item
4983 A small memory reserve is always held back that can be reached by
4984 @code{breathing_space}. If nothing more is left, we create a new reserve
4985 and exit. 
4986 @end enumerate
4987
4988 @node mark_object
4989 @subsection @code{mark_object}
4990 @cindex @code{mark_object}
4991
4992 The first thing that is checked while marking an object is whether the
4993 object is a real Lisp object @code{Lisp_Type_Record} or just an integer
4994 or a character. Integers and characters are the only two types that are
4995 stored directly - without another level of indirection, and therefore they
4996 don´t have to be marked and collected. 
4997 @xref{How Lisp Objects Are Represented in C}.
4998
4999 The second case is the one we have to handle. It is the one when we are
5000 dealing with a pointer to a Lisp object. But, there exist also three
5001 possibilities, that prevent us from doing anything while marking: The
5002 object is read only which prevents it from being garbage collected,
5003 i.e. marked (@code{C_READONLY_RECORD_HEADER}). The object in question is
5004 already marked, and need not be marked for the second time (checked by
5005 @code{MARKED_RECORD_HEADER_P}). If it is a special, unmarkable object
5006 (@code{UNMARKABLE_RECORD_HEADER_P}, apparently, these are objects that
5007 sit in some CONST space, and can therefore not be marked, see
5008 @code{this_one_is_unmarkable} in @code{alloc.c}).
5009
5010 Now, the actual marking is feasible. We do so by once using the macro
5011 @code{MARK_RECORD_HEADER} to mark the object itself (actually the
5012 special flag in the lrecord header), and calling its special marker
5013 "method" @code{marker} if available. The marker method marks every
5014 other object that is in reach from our current object. Note, that these 
5015 marker methods should not call @code{mark_object} recursively, but
5016 instead should return the next object from where further marking has to
5017 be performed.
5018
5019 In case another object was returned, as mentioned before, we reiterate
5020 the whole @code{mark_object} process beginning with this next object.
5021
5022 @node gc_sweep
5023 @subsection @code{gc_sweep}
5024 @cindex @code{gc_sweep}
5025
5026 The job of this function is to free all unmarked records from memory. As 
5027 we know, there are different types of objects implemented and managed, and
5028 consequently different ways to free them from memory.
5029 @xref{Introduction to Allocation}.
5030
5031 We start with all objects stored through @code{lcrecords}. All
5032 bulkier objects are allocated and handled using that scheme of
5033 @code{lcrecords}. Each object is @code{malloc}ed separately
5034 instead of placing it in one of the contiguous frob blocks. All types
5035 that are currently stored 
5036 using @code{lcrecords}´s  @code{alloc_lcrecord} and
5037 @code{make_lcrecord_list} are the types: vectors, buffers,
5038 char-table, char-table-entry, console, weak-list, database, device,
5039 ldap, hash-table, command-builder, extent-auxiliary, extent-info, face,
5040 coding-system, frame, image-instance, glyph, popup-data, gui-item,
5041 keymap, charset, color_instance, font_instance, opaque, opaque-list,
5042 process, range-table, specifier, symbol-value-buffer-local,
5043 symbol-value-lisp-magic, symbol-value-varalias, toolbar-button,
5044 tooltalk-message, tooltalk-pattern, window, and window-configuration. We
5045 take care of them in the fist place
5046 in order to be able to handle and to finalize items stored in them more
5047 easily. The function @code{sweep_lcrecords_1} as described below is
5048 doing the whole job for us.
5049 For a description about the internals: @xref{lrecords}.
5050
5051 Our next candidates are the other objects that behave quite differently
5052 than everything else: the strings. They consists of two parts, a
5053 fixed-size portion (@code{struct Lisp_string}) holding the string's
5054 length, its property list and a pointer to the second part, and the
5055 actual string data, which is stored in string-chars blocks comparable to
5056 frob blocks. In this block, the data is not only freed, but also a
5057 compression of holes is made, i.e. all strings are relocated together.
5058 @xref{String}. This compacting phase is performed by the function
5059 @code{compact_string_chars}, the actual sweeping by the function
5060 @code{sweep_strings} is described below.
5061
5062 After that, the other types are swept step by step using functions
5063 @code{sweep_conses}, @code{sweep_bit_vectors_1},
5064 @code{sweep_compiled_functions}, @code{sweep_floats},
5065 @code{sweep_symbols}, @code{sweep_extents}, @code{sweep_markers} and
5066 @code{sweep_extents}.  They are the fixed-size types cons, floats,
5067 compiled-functions, symbol, marker, extent, and event stored in
5068 so-called "frob blocks", and therefore we can basically do the same on
5069 every type objects, using the same macros, especially defined only to
5070 handle everything with respect to fixed-size blocks. The only fixed-size 
5071 type that is not handled here are the fixed-size portion of strings,
5072 because we took special care of them earlier.
5073
5074 The only big exceptions are bit vectors stored differently and
5075 therefore treated differently by the function @code{sweep_bit_vectors_1} 
5076 described later.
5077
5078 At first, we need some brief information about how
5079 these fixed-size types are managed in general, in order to understand
5080 how the sweeping is done. They have all a fixed size, and are therefore
5081 stored in big blocks of memory - allocated at once - that can hold a
5082 certain amount of objects of one type. The macro
5083 @code{DECLARE_FIXED_TYPE_ALLOC} creates the suitable structures for
5084 every type. More precisely, we have the block struct 
5085 (holding a pointer to the previous block @code{prev} and the
5086 objects in @code{block[]}), a pointer to current block
5087 (@code{current_..._block)}) and its last index
5088 (@code{current_..._block_index}), and a pointer to the free list that
5089 will be created. Also a macro @code{FIXED_TYPE_FROM_BLOCK} plus some
5090 related macros exists that are used to obtain a new object, either from
5091 the free list @code{ALLOCATE_FIXED_TYPE_1} if there is an unused object
5092 of that type stored or by allocating a completely new block using
5093 @code{ALLOCATE_FIXED_TYPE_FROM_BLOCK}.
5094
5095 The rest works as follows: all of them define a
5096 macro @code{UNMARK_...} that is used to unmark the object. They define a
5097 macro @code{ADDITIONAL_FREE_...} that defines additional work that has
5098 to be done when converting an object from in use to not in use (so far,
5099 only markers use it in order to unchain them). Then, they all call
5100 the macro @code{SWEEP_FIXED_TYPE_BLOCK} instantiated with their type name 
5101 and their struct name.
5102
5103 This call in particular does the following: we go over all blocks
5104 starting with the current moving towards the oldest.
5105 For each block, we look at every object in it. If the object already
5106 freed (checked with @code{FREE_STRUCT_P} using the first pointer of the
5107 object), or if it is 
5108 set to read only (@code{C_READONLY_RECORD_HEADER_P}, nothing must be
5109 done. If it is unmarked (checked with @code{MARKED_RECORD_HEADER_P}), it
5110 is put in the free list and set free (using the macro
5111 @code{FREE_FIXED_TYPE}, otherwise it stays in the block, but is unmarked 
5112 (by @code{UNMARK_...}). While going through one block, we note if the
5113 whole block is empty. If so, the whole block is freed (using
5114 @code{xfree}) and the free list state is set to the state it had before
5115 handling this block.
5116
5117 @node sweep_lcrecords_1
5118 @subsection @code{sweep_lcrecords_1}
5119 @cindex @code{sweep_lcrecords_1}
5120
5121 After nullifying the complete lcrecord statistics, we go over all
5122 lcrecords two separate times. They are all chained together in a list with 
5123 a head called @code{all_lcrecords}. 
5124
5125 The first loop calls for each object its @code{finalizer} method, but only 
5126 in the case that it is not read only
5127 (@code{C_READONLY_RECORD_HEADER_P)}, it is not already marked
5128 (@code{MARKED_RECORD_HEADER_P}), it is not already in a free list (list of
5129 freed objects, field @code{free}) and finally it owns a finalizer
5130 method.
5131  
5132 The second loop actually frees the appropriate objects again by iterating 
5133 through the whole list. In case an object is read only or marked, it 
5134 has to persist, otherwise it is manually freed by calling
5135 @code{xfree}. During this loop, the lcrecord statistics are kept up to
5136 date by calling @code{tick_lcrecord_stats} with the right arguments, 
5137
5138 @node compact_string_chars
5139 @subsection @code{compact_string_chars}
5140 @cindex @code{compact_string_chars}
5141
5142 The purpose of this function is to compact all the data parts of the
5143 strings that are held in so-called @code{string_chars_block}, i.e. the
5144 strings that do not exceed a certain maximal length.
5145
5146 The procedure with which this is done is as follows. We are keeping two
5147 positions in the @code{string_chars_block}s using two pointer/integer
5148 pairs, namely @code{from_sb}/@code{from_pos} and
5149 @code{to_sb}/@code{to_pos}. They stand for the actual positions, from
5150 where to where, to copy the actually handled string. 
5151
5152 While going over all chained @code{string_char_block}s and their held
5153 strings, staring at @code{first_string_chars_block}, both pointers
5154 are advanced and eventually a string is copied from @code{from_sb} to
5155 @code{to_sb}, depending on the status of the pointed at strings.
5156
5157 More precisely, we can distinguish between the following actions.
5158 @itemize @bullet
5159 @item
5160 The string at @code{from_sb}'s position could be marked as free, which
5161 is indicated by an invalid pointer to the pointer that should point back 
5162 to the fixed size string object, and which is checked by
5163 @code{FREE_STRUCT_P}. In this case, the @code{from_sb}/@code{from_pos}
5164 is advanced to the next string, and nothing has to be copied.
5165 @item
5166 Also, if a string object itself is unmarked, nothing has to be
5167 copied. We likewise advance the @code{from_sb}/@code{from_pos}
5168 pair as described above.
5169 @item
5170 In all other cases, we have a marked string at hand. The string data 
5171 must be moved from the from-position to the to-position. In case
5172 there is not enough space in the actual @code{to_sb}-block, we advance
5173 this pointer to the beginning of the next block before copying. In case the
5174 from and to positions are different, we perform the
5175 actual copying using the library function @code{memmove}.
5176 @end itemize
5177
5178 After compacting, the pointer to the current
5179 @code{string_chars_block}, sitting in @code{current_string_chars_block},
5180 is reset on the last block to which we moved a string,
5181 i.e. @code{to_block}, and all remaining blocks (we know that they just
5182 carry garbage) are explicitly @code{xfree}d.
5183
5184 @node sweep_strings
5185 @subsection @code{sweep_strings}
5186 @cindex @code{sweep_strings}
5187
5188 The sweeping for the fixed sized string objects is essentially exactly
5189 the same as it is for all other fixed size types. As before, the freeing
5190 into the suitable free list is done by using the macro
5191 @code{SWEEP_FIXED_SIZE_BLOCK} after defining the right macros
5192 @code{UNMARK_string} and @code{ADDITIONAL_FREE_string}. These two
5193 definitions are a little bit special compared to the ones used
5194 for the other fixed size types.
5195
5196 @code{UNMARK_string} is defined the same way except some additional code 
5197 used for updating the bookkeeping information.
5198
5199 For strings, @code{ADDITIONAL_FREE_string} has to do something in
5200 addition: in case, the string was not allocated in a
5201 @code{string_chars_block} because it exceeded the maximal length, and
5202 therefore it was @code{malloc}ed separately, we know also @code{xfree}
5203 it explicitly.
5204
5205 @node sweep_bit_vectors_1
5206 @subsection @code{sweep_bit_vectors_1}
5207 @cindex @code{sweep_bit_vectors_1}
5208
5209 Bit vectors are also one of the rare types that are @code{malloc}ed
5210 individually. Consequently, while sweeping, all further needless
5211 bit vectors must be freed by hand. This is done, as one might imagine,
5212 the expected way: since they are all registered in a list called
5213 @code{all_bit_vectors}, all elements of that list are traversed,
5214 all unmarked bit vectors are unlinked by calling @code{xfree} and all of 
5215 them become unmarked.
5216 In addition, the bookkeeping information used for garbage 
5217 collector's output purposes is updated.
5218
5219 @node Integers and Characters
5220 @section Integers and Characters
5221
5222   Integer and character Lisp objects are created from integers using the
5223 macros @code{XSETINT()} and @code{XSETCHAR()} or the equivalent
5224 functions @code{make_int()} and @code{make_char()}. (These are actually
5225 macros on most systems.)  These functions basically just do some moving
5226 of bits around, since the integral value of the object is stored
5227 directly in the @code{Lisp_Object}.
5228
5229   @code{XSETINT()} and the like will truncate values given to them that
5230 are too big; i.e. you won't get the value you expected but the tag bits
5231 will at least be correct.
5232
5233 @node Allocation from Frob Blocks
5234 @section Allocation from Frob Blocks
5235
5236 The uninitialized memory required by a @code{Lisp_Object} of a particular type
5237 is allocated using
5238 @code{ALLOCATE_FIXED_TYPE()}.  This only occurs inside of the
5239 lowest-level object-creating functions in @file{alloc.c}:
5240 @code{Fcons()}, @code{make_float()}, @code{Fmake_byte_code()},
5241 @code{Fmake_symbol()}, @code{allocate_extent()},
5242 @code{allocate_event()}, @code{Fmake_marker()}, and
5243 @code{make_uninit_string()}.  The idea is that, for each type, there are
5244 a number of frob blocks (each 2K in size); each frob block is divided up
5245 into object-sized chunks.  Each frob block will have some of these
5246 chunks that are currently assigned to objects, and perhaps some that are
5247 free. (If a frob block has nothing but free chunks, it is freed at the
5248 end of the garbage collection cycle.)  The free chunks are stored in a
5249 free list, which is chained by storing a pointer in the first four bytes
5250 of the chunk. (Except for the free chunks at the end of the last frob
5251 block, which are handled using an index which points past the end of the
5252 last-allocated chunk in the last frob block.)
5253 @code{ALLOCATE_FIXED_TYPE()} first tries to retrieve a chunk from the
5254 free list; if that fails, it calls
5255 @code{ALLOCATE_FIXED_TYPE_FROM_BLOCK()}, which looks at the end of the
5256 last frob block for space, and creates a new frob block if there is
5257 none. (There are actually two versions of these macros, one of which is
5258 more defensive but less efficient and is used for error-checking.)
5259
5260 @node lrecords
5261 @section lrecords
5262
5263   [see @file{lrecord.h}]
5264
5265   All lrecords have at the beginning of their structure a @code{struct
5266 lrecord_header}.  This just contains a pointer to a @code{struct
5267 lrecord_implementation}, which is a structure containing method pointers
5268 and such.  There is one of these for each type, and it is a global,
5269 constant, statically-declared structure that is declared in the
5270 @code{DEFINE_LRECORD_IMPLEMENTATION()} macro. (This macro actually
5271 declares an array of two @code{struct lrecord_implementation}
5272 structures.  The first one contains all the standard method pointers,
5273 and is used in all normal circumstances.  During garbage collection,
5274 however, the lrecord is @dfn{marked} by bumping its implementation
5275 pointer by one, so that it points to the second structure in the array.
5276 This structure contains a special indication in it that it's a
5277 @dfn{marked-object} structure: the finalize method is the special
5278 function @code{this_marks_a_marked_record()}, and all other methods are
5279 null pointers.  At the end of garbage collection, all lrecords will
5280 either be reclaimed or unmarked by decrementing their implementation
5281 pointers, so this second structure pointer will never remain past
5282 garbage collection.
5283
5284   Simple lrecords (of type (c) above) just have a @code{struct
5285 lrecord_header} at their beginning.  lcrecords, however, actually have a
5286 @code{struct lcrecord_header}.  This, in turn, has a @code{struct
5287 lrecord_header} at its beginning, so sanity is preserved; but it also
5288 has a pointer used to chain all lcrecords together, and a special ID
5289 field used to distinguish one lcrecord from another. (This field is used
5290 only for debugging and could be removed, but the space gain is not
5291 significant.)
5292
5293   Simple lrecords are created using @code{ALLOCATE_FIXED_TYPE()}, just
5294 like for other frob blocks.  The only change is that the implementation
5295 pointer must be initialized correctly. (The implementation structure for
5296 an lrecord, or rather the pointer to it, is named @code{lrecord_float},
5297 @code{lrecord_extent}, @code{lrecord_buffer}, etc.)
5298
5299   lcrecords are created using @code{alloc_lcrecord()}.  This takes a
5300 size to allocate and an implementation pointer. (The size needs to be
5301 passed because some lcrecords, such as window configurations, are of
5302 variable size.) This basically just @code{malloc()}s the storage,
5303 initializes the @code{struct lcrecord_header}, and chains the lcrecord
5304 onto the head of the list of all lcrecords, which is stored in the
5305 variable @code{all_lcrecords}.  The calls to @code{alloc_lcrecord()}
5306 generally occur in the lowest-level allocation function for each lrecord
5307 type.
5308
5309 Whenever you create an lrecord, you need to call either
5310 @code{DEFINE_LRECORD_IMPLEMENTATION()} or
5311 @code{DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION()}.  This needs to be
5312 specified in a C file, at the top level.  What this actually does is
5313 define and initialize the implementation structure for the lrecord. (And
5314 possibly declares a function @code{error_check_foo()} that implements
5315 the @code{XFOO()} macro when error-checking is enabled.)  The arguments
5316 to the macros are the actual type name (this is used to construct the C
5317 variable name of the lrecord implementation structure and related
5318 structures using the @samp{##} macro concatenation operator), a string
5319 that names the type on the Lisp level (this may not be the same as the C
5320 type name; typically, the C type name has underscores, while the Lisp
5321 string has dashes), various method pointers, and the name of the C
5322 structure that contains the object.  The methods are used to encapsulate
5323 type-specific information about the object, such as how to print it or
5324 mark it for garbage collection, so that it's easy to add new object
5325 types without having to add a specific case for each new type in a bunch
5326 of different places.
5327
5328   The difference between @code{DEFINE_LRECORD_IMPLEMENTATION()} and
5329 @code{DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION()} is that the former is
5330 used for fixed-size object types and the latter is for variable-size
5331 object types.  Most object types are fixed-size; some complex
5332 types, however (e.g. window configurations), are variable-size.
5333 Variable-size object types have an extra method, which is called
5334 to determine the actual size of a particular object of that type.
5335 (Currently this is only used for keeping allocation statistics.)
5336
5337   For the purpose of keeping allocation statistics, the allocation
5338 engine keeps a list of all the different types that exist.  Note that,
5339 since @code{DEFINE_LRECORD_IMPLEMENTATION()} is a macro that is
5340 specified at top-level, there is no way for it to add to the list of all
5341 existing types.  What happens instead is that each implementation
5342 structure contains in it a dynamically assigned number that is
5343 particular to that type. (Or rather, it contains a pointer to another
5344 structure that contains this number.  This evasiveness is done so that
5345 the implementation structure can be declared const.) In the sweep stage
5346 of garbage collection, each lrecord is examined to see if its
5347 implementation structure has its dynamically-assigned number set.  If
5348 not, it must be a new type, and it is added to the list of known types
5349 and a new number assigned.  The number is used to index into an array
5350 holding the number of objects of each type and the total memory
5351 allocated for objects of that type.  The statistics in this array are
5352 also computed during the sweep stage.  These statistics are returned by
5353 the call to @code{garbage-collect} and are printed out at the end of the
5354 loadup phase.
5355
5356   Note that for every type defined with a @code{DEFINE_LRECORD_*()}
5357 macro, there needs to be a @code{DECLARE_LRECORD_IMPLEMENTATION()}
5358 somewhere in a @file{.h} file, and this @file{.h} file needs to be
5359 included by @file{inline.c}.
5360
5361   Furthermore, there should generally be a set of @code{XFOOBAR()},
5362 @code{FOOBARP()}, etc. macros in a @file{.h} (or occasionally @file{.c})
5363 file.  To create one of these, copy an existing model and modify as
5364 necessary.
5365
5366   The various methods in the lrecord implementation structure are:
5367
5368 @enumerate
5369 @item
5370 @cindex mark method
5371 A @dfn{mark} method.  This is called during the marking stage and passed
5372 a function pointer (usually the @code{mark_object()} function), which is
5373 used to mark an object.  All Lisp objects that are contained within the
5374 object need to be marked by applying this function to them.  The mark
5375 method should also return a Lisp object, which should be either nil or
5376 an object to mark. (This can be used in lieu of calling
5377 @code{mark_object()} on the object, to reduce the recursion depth, and
5378 consequently should be the most heavily nested sub-object, such as a
5379 long list.)
5380
5381 @strong{Please note:} When the mark method is called, garbage collection
5382 is in progress, and special precautions need to be taken when accessing
5383 objects; see section (B) above.
5384
5385 If your mark method does not need to do anything, it can be
5386 @code{NULL}.
5387
5388 @item
5389 A @dfn{print} method.  This is called to create a printed representation
5390 of the object, whenever @code{princ}, @code{prin1}, or the like is
5391 called.  It is passed the object, a stream to which the output is to be
5392 directed, and an @code{escapeflag} which indicates whether the object's
5393 printed representation should be @dfn{escaped} so that it is
5394 readable. (This corresponds to the difference between @code{princ} and
5395 @code{prin1}.) Basically, @dfn{escaped} means that strings will have
5396 quotes around them and confusing characters in the strings such as
5397 quotes, backslashes, and newlines will be backslashed; and that special
5398 care will be taken to make symbols print in a readable fashion
5399 (e.g. symbols that look like numbers will be backslashed).  Other
5400 readable objects should perhaps pass @code{escapeflag} on when
5401 sub-objects are printed, so that readability is preserved when necessary
5402 (or if not, always pass in a 1 for @code{escapeflag}).  Non-readable
5403 objects should in general ignore @code{escapeflag}, except that some use
5404 it as an indication that more verbose output should be given.
5405
5406 Sub-objects are printed using @code{print_internal()}, which takes
5407 exactly the same arguments as are passed to the print method.
5408
5409 Literal C strings should be printed using @code{write_c_string()},
5410 or @code{write_string_1()} for non-null-terminated strings.
5411
5412 Functions that do not have a readable representation should check the
5413 @code{print_readably} flag and signal an error if it is set.
5414
5415 If you specify NULL for the print method, the
5416 @code{default_object_printer()} will be used.
5417
5418 @item
5419 A @dfn{finalize} method.  This is called at the beginning of the sweep
5420 stage on lcrecords that are about to be freed, and should be used to
5421 perform any extra object cleanup.  This typically involves freeing any
5422 extra @code{malloc()}ed memory associated with the object, releasing any
5423 operating-system and window-system resources associated with the object
5424 (e.g. pixmaps, fonts), etc.
5425
5426 The finalize method can be NULL if nothing needs to be done.
5427
5428 WARNING #1: The finalize method is also called at the end of the dump
5429 phase; this time with the for_disksave parameter set to non-zero.  The
5430 object is @emph{not} about to disappear, so you have to make sure to
5431 @emph{not} free any extra @code{malloc()}ed memory if you're going to
5432 need it later.  (Also, signal an error if there are any operating-system
5433 and window-system resources here, because they can't be dumped.)
5434
5435 Finalize methods should, as a rule, set to zero any pointers after
5436 they've been freed, and check to make sure pointers are not zero before
5437 freeing.  Although I'm pretty sure that finalize methods are not called
5438 twice on the same object (except for the @code{for_disksave} proviso),
5439 we've gotten nastily burned in some cases by not doing this.
5440
5441 WARNING #2: The finalize method is @emph{only} called for
5442 lcrecords, @emph{not} for simply lrecords.  If you need a
5443 finalize method for simple lrecords, you have to stick
5444 it in the @code{ADDITIONAL_FREE_foo()} macro in @file{alloc.c}.
5445
5446 WARNING #3: Things are in an @emph{extremely} bizarre state
5447 when @code{ADDITIONAL_FREE_foo()} is called, so you have to
5448 be incredibly careful when writing one of these functions.
5449 See the comment in @code{gc_sweep()}.  If you ever have to add
5450 one of these, consider using an lcrecord or dealing with
5451 the problem in a different fashion.
5452
5453 @item
5454 An @dfn{equal} method.  This compares the two objects for similarity,
5455 when @code{equal} is called.  It should compare the contents of the
5456 objects in some reasonable fashion.  It is passed the two objects and a
5457 @dfn{depth} value, which is used to catch circular objects.  To compare
5458 sub-Lisp-objects, call @code{internal_equal()} and bump the depth value
5459 by one.  If this value gets too high, a @code{circular-object} error
5460 will be signaled.
5461
5462 If this is NULL, objects are @code{equal} only when they are @code{eq},
5463 i.e. identical.
5464
5465 @item
5466 A @dfn{hash} method.  This is used to hash objects when they are to be
5467 compared with @code{equal}.  The rule here is that if two objects are
5468 @code{equal}, they @emph{must} hash to the same value; i.e. your hash
5469 function should use some subset of the sub-fields of the object that are
5470 compared in the ``equal'' method.  If you specify this method as
5471 @code{NULL}, the object's pointer will be used as the hash, which will
5472 @emph{fail} if the object has an @code{equal} method, so don't do this.
5473
5474 To hash a sub-Lisp-object, call @code{internal_hash()}.  Bump the
5475 depth by one, just like in the ``equal'' method.
5476
5477 To convert a Lisp object directly into a hash value (using
5478 its pointer), use @code{LISP_HASH()}.  This is what happens when
5479 the hash method is NULL.
5480
5481 To hash two or more values together into a single value, use
5482 @code{HASH2()}, @code{HASH3()}, @code{HASH4()}, etc.
5483
5484 @item
5485 @dfn{getprop}, @dfn{putprop}, @dfn{remprop}, and @dfn{plist} methods.
5486 These are used for object types that have properties.  I don't feel like
5487 documenting them here.  If you create one of these objects, you have to
5488 use different macros to define them,
5489 i.e. @code{DEFINE_LRECORD_IMPLEMENTATION_WITH_PROPS()} or
5490 @code{DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION_WITH_PROPS()}.
5491
5492 @item
5493 A @dfn{size_in_bytes} method, when the object is of variable-size.
5494 (i.e. declared with a @code{_SEQUENCE_IMPLEMENTATION} macro.)  This should
5495 simply return the object's size in bytes, exactly as you might expect.
5496 For an example, see the methods for window configurations and opaques.
5497 @end enumerate
5498
5499 @node Low-level allocation
5500 @section Low-level allocation
5501
5502   Memory that you want to allocate directly should be allocated using
5503 @code{xmalloc()} rather than @code{malloc()}.  This implements
5504 error-checking on the return value, and once upon a time did some more
5505 vital stuff (i.e. @code{BLOCK_INPUT}, which is no longer necessary).
5506 Free using @code{xfree()}, and realloc using @code{xrealloc()}.  Note
5507 that @code{xmalloc()} will do a non-local exit if the memory can't be
5508 allocated. (Many functions, however, do not expect this, and thus XEmacs
5509 will likely crash if this happens.  @strong{This is a bug.}  If you can,
5510 you should strive to make your function handle this OK.  However, it's
5511 difficult in the general circumstance, perhaps requiring extra
5512 unwind-protects and such.)
5513
5514   Note that XEmacs provides two separate replacements for the standard
5515 @code{malloc()} library function.  These are called @dfn{old GNU malloc}
5516 (@file{malloc.c}) and @dfn{new GNU malloc} (@file{gmalloc.c}),
5517 respectively.  New GNU malloc is better in pretty much every way than
5518 old GNU malloc, and should be used if possible.  (It used to be that on
5519 some systems, the old one worked but the new one didn't.  I think this
5520 was due specifically to a bug in SunOS, which the new one now works
5521 around; so I don't think the old one ever has to be used any more.) The
5522 primary difference between both of these mallocs and the standard system
5523 malloc is that they are much faster, at the expense of increased space.
5524 The basic idea is that memory is allocated in fixed chunks of powers of
5525 two.  This allows for basically constant malloc time, since the various
5526 chunks can just be kept on a number of free lists. (The standard system
5527 malloc typically allocates arbitrary-sized chunks and has to spend some
5528 time, sometimes a significant amount of time, walking the heap looking
5529 for a free block to use and cleaning things up.)  The new GNU malloc
5530 improves on things by allocating large objects in chunks of 4096 bytes
5531 rather than in ever larger powers of two, which results in ever larger
5532 wastage.  There is a slight speed loss here, but it's of doubtful
5533 significance.
5534
5535   NOTE: Apparently there is a third-generation GNU malloc that is
5536 significantly better than the new GNU malloc, and should probably
5537 be included in XEmacs.
5538
5539   There is also the relocating allocator, @file{ralloc.c}.  This actually
5540 moves blocks of memory around so that the @code{sbrk()} pointer shrunk
5541 and virtual memory released back to the system.  On some systems,
5542 this is a big win.  On all systems, it causes a noticeable (and
5543 sometimes huge) speed penalty, so I turn it off by default.
5544 @file{ralloc.c} only works with the new GNU malloc in @file{gmalloc.c}.
5545 There are also two versions of @file{ralloc.c}, one that uses @code{mmap()}
5546 rather than block copies to move data around.  This purports to
5547 be faster, although that depends on the amount of data that would
5548 have had to be block copied and the system-call overhead for
5549 @code{mmap()}.  I don't know exactly how this works, except that the
5550 relocating-allocation routines are pretty much used only for
5551 the memory allocated for a buffer, which is the biggest consumer
5552 of space, esp. of space that may get freed later.
5553
5554   Note that the GNU mallocs have some ``memory warning'' facilities.
5555 XEmacs taps into them and issues a warning through the standard
5556 warning system, when memory gets to 75%, 85%, and 95% full.
5557 (On some systems, the memory warnings are not functional.)
5558
5559   Allocated memory that is going to be used to make a Lisp object
5560 is created using @code{allocate_lisp_storage()}.  This calls @code{xmalloc()}
5561 but also verifies that the pointer to the memory can fit into
5562 a Lisp word (remember that some bits are taken away for a type
5563 tag and a mark bit).  If not, an error is issued through @code{memory_full()}.
5564 @code{allocate_lisp_storage()} is called by @code{alloc_lcrecord()},
5565 @code{ALLOCATE_FIXED_TYPE()}, and the vector and bit-vector creation
5566 routines.  These routines also call @code{INCREMENT_CONS_COUNTER()} at the
5567 appropriate times; this keeps statistics on how much memory is
5568 allocated, so that garbage-collection can be invoked when the
5569 threshold is reached.
5570
5571 @node Pure Space
5572 @section Pure Space
5573
5574   Not yet documented.
5575
5576 @node Cons
5577 @section Cons
5578
5579   Conses are allocated in standard frob blocks.  The only thing to
5580 note is that conses can be explicitly freed using @code{free_cons()}
5581 and associated functions @code{free_list()} and @code{free_alist()}.  This
5582 immediately puts the conses onto the cons free list, and decrements
5583 the statistics on memory allocation appropriately.  This is used
5584 to good effect by some extremely commonly-used code, to avoid
5585 generating extra objects and thereby triggering GC sooner.
5586 However, you have to be @emph{extremely} careful when doing this.
5587 If you mess this up, you will get BADLY BURNED, and it has happened
5588 before.
5589
5590 @node Vector
5591 @section Vector
5592
5593   As mentioned above, each vector is @code{malloc()}ed individually, and
5594 all are threaded through the variable @code{all_vectors}.  Vectors are
5595 marked strangely during garbage collection, by kludging the size field.
5596 Note that the @code{struct Lisp_Vector} is declared with its
5597 @code{contents} field being a @emph{stretchy} array of one element.  It
5598 is actually @code{malloc()}ed with the right size, however, and access
5599 to any element through the @code{contents} array works fine.
5600
5601 @node Bit Vector
5602 @section Bit Vector
5603
5604   Bit vectors work exactly like vectors, except for more complicated
5605 code to access an individual bit, and except for the fact that bit
5606 vectors are lrecords while vectors are not. (The only difference here is
5607 that there's an lrecord implementation pointer at the beginning and the
5608 tag field in bit vector Lisp words is ``lrecord'' rather than
5609 ``vector''.)
5610
5611 @node Symbol
5612 @section Symbol
5613
5614   Symbols are also allocated in frob blocks.  Note that the code
5615 exists for symbols to be either lrecords (category (c) above)
5616 or simple types (category (b) above), and are lrecords by
5617 default (I think), although there is no good reason for this.
5618
5619   Note that symbols in the awful horrible obarray structure are
5620 chained through their @code{next} field.
5621
5622 Remember that @code{intern} looks up a symbol in an obarray, creating
5623 one if necessary.
5624
5625 @node Marker
5626 @section Marker
5627
5628   Markers are allocated in frob blocks, as usual.  They are kept
5629 in a buffer unordered, but in a doubly-linked list so that they
5630 can easily be removed. (Formerly this was a singly-linked list,
5631 but in some cases garbage collection took an extraordinarily
5632 long time due to the O(N^2) time required to remove lots of
5633 markers from a buffer.) Markers are removed from a buffer in
5634 the finalize stage, in @code{ADDITIONAL_FREE_marker()}.
5635
5636 @node String
5637 @section String
5638
5639   As mentioned above, strings are a special case.  A string is logically
5640 two parts, a fixed-size object (containing the length, property list,
5641 and a pointer to the actual data), and the actual data in the string.
5642 The fixed-size object is a @code{struct Lisp_String} and is allocated in
5643 frob blocks, as usual.  The actual data is stored in special
5644 @dfn{string-chars blocks}, which are 8K blocks of memory.
5645 Currently-allocated strings are simply laid end to end in these
5646 string-chars blocks, with a pointer back to the @code{struct Lisp_String}
5647 stored before each string in the string-chars block.  When a new string
5648 needs to be allocated, the remaining space at the end of the last
5649 string-chars block is used if there's enough, and a new string-chars
5650 block is created otherwise.
5651
5652   There are never any holes in the string-chars blocks due to the string
5653 compaction and relocation that happens at the end of garbage collection.
5654 During the sweep stage of garbage collection, when objects are
5655 reclaimed, the garbage collector goes through all string-chars blocks,
5656 looking for unused strings.  Each chunk of string data is preceded by a
5657 pointer to the corresponding @code{struct Lisp_String}, which indicates
5658 both whether the string is used and how big the string is, i.e. how to
5659 get to the next chunk of string data.  Holes are compressed by
5660 block-copying the next string into the empty space and relocating the
5661 pointer stored in the corresponding @code{struct Lisp_String}.
5662 @strong{This means you have to be careful with strings in your code.}
5663 See the section above on @code{GCPRO}ing.
5664
5665   Note that there is one situation not handled: a string that is too big
5666 to fit into a string-chars block.  Such strings, called @dfn{big
5667 strings}, are all @code{malloc()}ed as their own block. (#### Although it
5668 would make more sense for the threshold for big strings to be somewhat
5669 lower, e.g. 1/2 or 1/4 the size of a string-chars block.  It seems that
5670 this was indeed the case formerly -- indeed, the threshold was set at
5671 1/8 -- but Mly forgot about this when rewriting things for 19.8.)
5672
5673 Note also that the string data in string-chars blocks is padded as
5674 necessary so that proper alignment constraints on the @code{struct
5675 Lisp_String} back pointers are maintained.
5676
5677   Finally, strings can be resized.  This happens in Mule when a
5678 character is substituted with a different-length character, or during
5679 modeline frobbing. (You could also export this to Lisp, but it's not
5680 done so currently.) Resizing a string is a potentially tricky process.
5681 If the change is small enough that the padding can absorb it, nothing
5682 other than a simple memory move needs to be done.  Keep in mind,
5683 however, that the string can't shrink too much because the offset to the
5684 next string in the string-chars block is computed by looking at the
5685 length and rounding to the nearest multiple of four or eight.  If the
5686 string would shrink or expand beyond the correct padding, new string
5687 data needs to be allocated at the end of the last string-chars block and
5688 the data moved appropriately.  This leaves some dead string data, which
5689 is marked by putting a special marker of 0xFFFFFFFF in the @code{struct
5690 Lisp_String} pointer before the data (there's no real @code{struct
5691 Lisp_String} to point to and relocate), and storing the size of the dead
5692 string data (which would normally be obtained from the now-non-existent
5693 @code{struct Lisp_String}) at the beginning of the dead string data gap.
5694 The string compactor recognizes this special 0xFFFFFFFF marker and
5695 handles it correctly.
5696
5697 @node Compiled Function
5698 @section Compiled Function
5699
5700   Not yet documented.
5701
5702 @node Events and the Event Loop, Evaluation; Stack Frames; Bindings, Allocation of Objects in XEmacs Lisp, Top
5703 @chapter Events and the Event Loop
5704
5705 @menu
5706 * Introduction to Events::
5707 * Main Loop::
5708 * Specifics of the Event Gathering Mechanism::
5709 * Specifics About the Emacs Event::
5710 * The Event Stream Callback Routines::
5711 * Other Event Loop Functions::
5712 * Converting Events::
5713 * Dispatching Events; The Command Builder::
5714 @end menu
5715
5716 @node Introduction to Events
5717 @section Introduction to Events
5718
5719   An event is an object that encapsulates information about an
5720 interesting occurrence in the operating system.  Events are
5721 generated either by user action, direct (e.g. typing on the
5722 keyboard or moving the mouse) or indirect (moving another
5723 window, thereby generating an expose event on an Emacs frame),
5724 or as a result of some other typically asynchronous action happening,
5725 such as output from a subprocess being ready or a timer expiring.
5726 Events come into the system in an asynchronous fashion (typically
5727 through a callback being called) and are converted into a
5728 synchronous event queue (first-in, first-out) in a process that
5729 we will call @dfn{collection}.
5730
5731   Note that each application has its own event queue. (It is
5732 immaterial whether the collection process directly puts the
5733 events in the proper application's queue, or puts them into
5734 a single system queue, which is later split up.)
5735
5736   The most basic level of event collection is done by the
5737 operating system or window system.  Typically, XEmacs does
5738 its own event collection as well.  Often there are multiple
5739 layers of collection in XEmacs, with events from various
5740 sources being collected into a queue, which is then combined
5741 with other sources to go into another queue (i.e. a second
5742 level of collection), with perhaps another level on top of
5743 this, etc.
5744
5745   XEmacs has its own types of events (called @dfn{Emacs events}),
5746 which provides an abstract layer on top of the system-dependent
5747 nature of the most basic events that are received.  Part of the
5748 complex nature of the XEmacs event collection process involves
5749 converting from the operating-system events into the proper
5750 Emacs events -- there may not be a one-to-one correspondence.
5751
5752   Emacs events are documented in @file{events.h}; I'll discuss them
5753 later.
5754
5755 @node Main Loop
5756 @section Main Loop
5757
5758   The @dfn{command loop} is the top-level loop that the editor is always
5759 running.  It loops endlessly, calling @code{next-event} to retrieve an
5760 event and @code{dispatch-event} to execute it. @code{dispatch-event} does
5761 the appropriate thing with non-user events (process, timeout,
5762 magic, eval, mouse motion); this involves calling a Lisp handler
5763 function, redrawing a newly-exposed part of a frame, reading
5764 subprocess output, etc.  For user events, @code{dispatch-event}
5765 looks up the event in relevant keymaps or menubars; when a
5766 full key sequence or menubar selection is reached, the appropriate
5767 function is executed. @code{dispatch-event} may have to keep state
5768 across calls; this is done in the ``command-builder'' structure
5769 associated with each console (remember, there's usually only
5770 one console), and the engine that looks up keystrokes and
5771 constructs full key sequences is called the @dfn{command builder}.
5772 This is documented elsewhere.
5773
5774   The guts of the command loop are in @code{command_loop_1()}.  This
5775 function doesn't catch errors, though -- that's the job of
5776 @code{command_loop_2()}, which is a condition-case (i.e. error-trapping)
5777 wrapper around @code{command_loop_1()}.  @code{command_loop_1()} never
5778 returns, but may get thrown out of.
5779
5780   When an error occurs, @code{cmd_error()} is called, which usually
5781 invokes the Lisp error handler in @code{command-error}; however, a
5782 default error handler is provided if @code{command-error} is @code{nil}
5783 (e.g. during startup).  The purpose of the error handler is simply to
5784 display the error message and do associated cleanup; it does not need to
5785 throw anywhere.  When the error handler finishes, the condition-case in
5786 @code{command_loop_2()} will finish and @code{command_loop_2()} will
5787 reinvoke @code{command_loop_1()}.
5788
5789   @code{command_loop_2()} is invoked from three places: from
5790 @code{initial_command_loop()} (called from @code{main()} at the end of
5791 internal initialization), from the Lisp function @code{recursive-edit},
5792 and from @code{call_command_loop()}.
5793
5794   @code{call_command_loop()} is called when a macro is started and when
5795 the minibuffer is entered; normal termination of the macro or minibuffer
5796 causes a throw out of the recursive command loop. (To
5797 @code{execute-kbd-macro} for macros and @code{exit} for minibuffers.
5798 Note also that the low-level minibuffer-entering function,
5799 @code{read-minibuffer-internal}, provides its own error handling and
5800 does not need @code{command_loop_2()}'s error encapsulation; so it tells
5801 @code{call_command_loop()} to invoke @code{command_loop_1()} directly.)
5802
5803   Note that both read-minibuffer-internal and recursive-edit set up a
5804 catch for @code{exit}; this is why @code{abort-recursive-edit}, which
5805 throws to this catch, exits out of either one.
5806
5807   @code{initial_command_loop()}, called from @code{main()}, sets up a
5808 catch for @code{top-level} when invoking @code{command_loop_2()},
5809 allowing functions to throw all the way to the top level if they really
5810 need to.  Before invoking @code{command_loop_2()},
5811 @code{initial_command_loop()} calls @code{top_level_1()}, which handles
5812 all of the startup stuff (creating the initial frame, handling the
5813 command-line options, loading the user's @file{.emacs} file, etc.).  The
5814 function that actually does this is in Lisp and is pointed to by the
5815 variable @code{top-level}; normally this function is
5816 @code{normal-top-level}.  @code{top_level_1()} is just an error-handling
5817 wrapper similar to @code{command_loop_2()}.  Note also that
5818 @code{initial_command_loop()} sets up a catch for @code{top-level} when
5819 invoking @code{top_level_1()}, just like when it invokes
5820 @code{command_loop_2()}.
5821
5822 @node Specifics of the Event Gathering Mechanism
5823 @section Specifics of the Event Gathering Mechanism
5824
5825   Here is an approximate diagram of the collection processes
5826 at work in XEmacs, under TTY's (TTY's are simpler than X
5827 so we'll look at this first):
5828
5829 @noindent
5830 @example
5831  asynch.      asynch.    asynch.   asynch.             [Collectors in
5832 kbd events  kbd events   process   process                the OS]
5833       |         |         output    output
5834       |         |           |         |
5835       |         |           |         |      SIGINT,   [signal handlers
5836       |         |           |         |      SIGQUIT,     in XEmacs]
5837       V         V           V         V      SIGWINCH,
5838      file      file        file      file    SIGALRM
5839      desc.     desc.       desc.     desc.     |
5840      (TTY)     (TTY)       (pipe)    (pipe)    |
5841       |          |          |         |      fake    timeouts
5842       |          |          |         |      file        |
5843       |          |          |         |      desc.       |
5844       |          |          |         |      (pipe)      |
5845       |          |          |         |        |         |
5846       |          |          |         |        |         |
5847       |          |          |         |        |         |
5848       V          V          V         V        V         V
5849       ------>-----------<----------------<----------------
5850                   |
5851                   |
5852                   | [collected using select() in emacs_tty_next_event()
5853                   |  and converted to the appropriate Emacs event]
5854                   |
5855                   |
5856                   V          (above this line is TTY-specific)
5857                 Emacs -----------------------------------------------
5858                 event (below this line is the generic event mechanism)
5859                   |
5860                   |
5861 was there     if not, call
5862 a SIGINT?  emacs_tty_next_event()
5863     |             |
5864     |             |
5865     |             |
5866     V             V
5867     --->------<----
5868            |
5869            |     [collected in event_stream_next_event();
5870            |      SIGINT is converted using maybe_read_quit_event()]
5871            V
5872          Emacs
5873          event
5874            |
5875            \---->------>----- maybe_kbd_translate() ---->---\
5876                                                             |
5877                                                             |
5878                                                             |
5879      command event queue                                    |
5880                                                if not from command
5881   (contains events that were                   event queue, call
5882   read earlier but not processed,              event_stream_next_event()
5883   typically when waiting in a                               |
5884   sit-for, sleep-for, etc. for                              |
5885  a particular event to be received)                         |
5886                |                                            |
5887                |                                            |
5888                V                                            V
5889                ---->------------------------------------<----
5890                                                |
5891                                                | [collected in
5892                                                |  next_event_internal()]
5893                                                |
5894  unread-     unread-       event from          |
5895  command-    command-       keyboard       else, call
5896  events      event           macro      next_event_internal()
5897    |           |               |               |
5898    |           |               |               |
5899    |           |               |               |
5900    V           V               V               V
5901    --------->----------------------<------------
5902                      |
5903                      |      [collected in `next-event', which may loop
5904                      |       more than once if the event it gets is on
5905                      |       a dead frame, device, etc.]
5906                      |
5907                      |
5908                      V
5909             feed into top-level event loop,
5910             which repeatedly calls `next-event'
5911             and then dispatches the event
5912             using `dispatch-event'
5913 @end example
5914
5915 Notice the separation between TTY-specific and generic event mechanism.
5916 When using the Xt-based event loop, the TTY-specific stuff is replaced
5917 but the rest stays the same.
5918
5919 It's also important to realize that only one different kind of
5920 system-specific event loop can be operating at a time, and must be able
5921 to receive all kinds of events simultaneously.  For the two existing
5922 event loops (implemented in @file{event-tty.c} and @file{event-Xt.c},
5923 respectively), the TTY event loop @emph{only} handles TTY consoles,
5924 while the Xt event loop handles @emph{both} TTY and X consoles.  This
5925 situation is different from all of the output handlers, where you simply
5926 have one per console type.
5927
5928   Here's the Xt Event Loop Diagram (notice that below a certain point,
5929 it's the same as the above diagram):
5930
5931 @example
5932 asynch. asynch. asynch. asynch.                 [Collectors in
5933  kbd     kbd    process process                    the OS]
5934 events  events  output  output
5935   |       |       |       |
5936   |       |       |       |     asynch. asynch. [Collectors in the
5937   |       |       |       |       X        X     OS and X Window System]
5938   |       |       |       |     events  events
5939   |       |       |       |       |        |
5940   |       |       |       |       |        |
5941   |       |       |       |       |        |    SIGINT, [signal handlers
5942   |       |       |       |       |        |    SIGQUIT,   in XEmacs]
5943   |       |       |       |       |        |    SIGWINCH,
5944   |       |       |       |       |        |    SIGALRM
5945   |       |       |       |       |        |       |
5946   |       |       |       |       |        |       |
5947   |       |       |       |       |        |       |      timeouts
5948   |       |       |       |       |        |       |          |
5949   |       |       |       |       |        |       |          |
5950   |       |       |       |       |        |       V          |
5951   V       V       V       V       V        V      fake        |
5952  file    file    file    file    file     file    file        |
5953  desc.   desc.   desc.   desc.   desc.    desc.   desc.       |
5954  (TTY)   (TTY)   (pipe)  (pipe) (socket) (socket) (pipe)      |
5955   |       |       |       |       |        |       |          |
5956   |       |       |       |       |        |       |          |
5957   |       |       |       |       |        |       |          |
5958   V       V       V       V       V        V       V          V
5959   --->----------------------------------------<---------<------
5960        |              |               |
5961        |              |               |[collected using select() in
5962        |              |               | _XtWaitForSomething(), called
5963        |              |               | from XtAppProcessEvent(), called
5964        |              |               | in emacs_Xt_next_event();
5965        |              |               | dispatched to various callbacks]
5966        |              |               |
5967        |              |               |
5968   emacs_Xt_        p_s_callback(),    | [popup_selection_callback]
5969   event_handler()  x_u_v_s_callback(),| [x_update_vertical_scrollbar_
5970        |           x_u_h_s_callback(),|  callback]
5971        |           search_callback()  | [x_update_horizontal_scrollbar_
5972        |              |               |  callback]
5973        |              |               |
5974        |              |               |
5975   enqueue_Xt_       signal_special_   |
5976   dispatch_event()  Xt_user_event()   |
5977   [maybe multiple     |               |
5978    times, maybe 0     |               |
5979    times]             |               |
5980        |            enqueue_Xt_       |
5981        |            dispatch_event()  |
5982        |              |               |
5983        |              |               |
5984        V              V               |
5985        -->----------<--               |
5986               |                       |
5987               |                       |
5988            dispatch             Xt_what_callback()
5989            event                  sets flags
5990            queue                      |
5991               |                       |
5992               |                       |
5993               |                       |
5994               |                       |
5995               ---->-----------<--------
5996                    |
5997                    |
5998                    |     [collected and converted as appropriate in
5999                    |            emacs_Xt_next_event()]
6000                    |
6001                    |
6002                    V          (above this line is Xt-specific)
6003                  Emacs ------------------------------------------------
6004                  event (below this line is the generic event mechanism)
6005                    |
6006                    |
6007 was there      if not, call
6008 a SIGINT?   emacs_Xt_next_event()
6009     |              |
6010     |              |
6011     |              |
6012     V              V
6013     --->-------<----
6014            |
6015            |        [collected in event_stream_next_event();
6016            |         SIGINT is converted using maybe_read_quit_event()]
6017            V
6018          Emacs
6019          event
6020            |
6021            \---->------>----- maybe_kbd_translate() -->-----\
6022                                                             |
6023                                                             |
6024                                                             |
6025      command event queue                                    |
6026                                               if not from command
6027   (contains events that were                  event queue, call
6028   read earlier but not processed,             event_stream_next_event()
6029   typically when waiting in a                               |
6030   sit-for, sleep-for, etc. for                              |
6031  a particular event to be received)                         |
6032                |                                            |
6033                |                                            |
6034                V                                            V
6035                ---->----------------------------------<------
6036                                                |
6037                                                | [collected in
6038                                                |  next_event_internal()]
6039                                                |
6040  unread-     unread-       event from          |
6041  command-    command-       keyboard       else, call
6042  events      event           macro      next_event_internal()
6043    |           |               |               |
6044    |           |               |               |
6045    |           |               |               |
6046    V           V               V               V
6047    --------->----------------------<------------
6048                      |
6049                      |      [collected in `next-event', which may loop
6050                      |       more than once if the event it gets is on
6051                      |       a dead frame, device, etc.]
6052                      |
6053                      |
6054                      V
6055             feed into top-level event loop,
6056             which repeatedly calls `next-event'
6057             and then dispatches the event
6058             using `dispatch-event'
6059 @end example
6060
6061 @node Specifics About the Emacs Event
6062 @section Specifics About the Emacs Event
6063
6064 @node The Event Stream Callback Routines
6065 @section The Event Stream Callback Routines
6066
6067 @node Other Event Loop Functions
6068 @section Other Event Loop Functions
6069
6070   @code{detect_input_pending()} and @code{input-pending-p} look for
6071 input by calling @code{event_stream->event_pending_p} and looking in
6072 @code{[V]unread-command-event} and the @code{command_event_queue} (they
6073 do not check for an executing keyboard macro, though).
6074
6075   @code{discard-input} cancels any command events pending (and any
6076 keyboard macros currently executing), and puts the others onto the
6077 @code{command_event_queue}.  There is a comment about a ``race
6078 condition'', which is not a good sign.
6079
6080   @code{next-command-event} and @code{read-char} are higher-level
6081 interfaces to @code{next-event}.  @code{next-command-event} gets the
6082 next @dfn{command} event (i.e.  keypress, mouse event, menu selection,
6083 or scrollbar action), calling @code{dispatch-event} on any others.
6084 @code{read-char} calls @code{next-command-event} and uses
6085 @code{event_to_character()} to return the character equivalent.  With
6086 the right kind of input method support, it is possible for (read-char)
6087 to return a Kanji character.
6088
6089 @node Converting Events
6090 @section Converting Events
6091
6092   @code{character_to_event()}, @code{event_to_character()},
6093 @code{event-to-character}, and @code{character-to-event} convert between
6094 characters and keypress events corresponding to the characters.  If the
6095 event was not a keypress, @code{event_to_character()} returns -1 and
6096 @code{event-to-character} returns @code{nil}.  These functions convert
6097 between character representation and the split-up event representation
6098 (keysym plus mod keys).
6099
6100 @node Dispatching Events; The Command Builder
6101 @section Dispatching Events; The Command Builder
6102
6103 Not yet documented.
6104
6105 @node Evaluation; Stack Frames; Bindings, Symbols and Variables, Events and the Event Loop, Top
6106 @chapter Evaluation; Stack Frames; Bindings
6107
6108 @menu
6109 * Evaluation::
6110 * Dynamic Binding; The specbinding Stack; Unwind-Protects::
6111 * Simple Special Forms::
6112 * Catch and Throw::
6113 @end menu
6114
6115 @node Evaluation
6116 @section Evaluation
6117
6118   @code{Feval()} evaluates the form (a Lisp object) that is passed to
6119 it.  Note that evaluation is only non-trivial for two types of objects:
6120 symbols and conses.  A symbol is evaluated simply by calling
6121 @code{symbol-value} on it and returning the value.
6122
6123   Evaluating a cons means calling a function.  First, @code{eval} checks
6124 to see if garbage-collection is necessary, and calls
6125 @code{garbage_collect_1()} if so.  It then increases the evaluation
6126 depth by 1 (@code{lisp_eval_depth}, which is always less than
6127 @code{max_lisp_eval_depth}) and adds an element to the linked list of
6128 @code{struct backtrace}'s (@code{backtrace_list}).  Each such structure
6129 contains a pointer to the function being called plus a list of the
6130 function's arguments.  Originally these values are stored unevalled, and
6131 as they are evaluated, the backtrace structure is updated.  Garbage
6132 collection pays attention to the objects pointed to in the backtrace
6133 structures (garbage collection might happen while a function is being
6134 called or while an argument is being evaluated, and there could easily
6135 be no other references to the arguments in the argument list; once an
6136 argument is evaluated, however, the unevalled version is not needed by
6137 eval, and so the backtrace structure is changed).
6138
6139 At this point, the function to be called is determined by looking at
6140 the car of the cons (if this is a symbol, its function definition is
6141 retrieved and the process repeated).  The function should then consist
6142 of either a @code{Lisp_Subr} (built-in function written in C), a
6143 @code{Lisp_Compiled_Function} object, or a cons whose car is one of the
6144 symbols @code{autoload}, @code{macro} or @code{lambda}.
6145
6146 If the function is a @code{Lisp_Subr}, the lisp object points to a
6147 @code{struct Lisp_Subr} (created by @code{DEFUN()}), which contains a
6148 pointer to the C function, a minimum and maximum number of arguments
6149 (or possibly the special constants @code{MANY} or @code{UNEVALLED}), a
6150 pointer to the symbol referring to that subr, and a couple of other
6151 things.  If the subr wants its arguments @code{UNEVALLED}, they are
6152 passed raw as a list.  Otherwise, an array of evaluated arguments is
6153 created and put into the backtrace structure, and either passed whole
6154 (@code{MANY}) or each argument is passed as a C argument.
6155
6156 If the function is a @code{Lisp_Compiled_Function},
6157 @code{funcall_compiled_function()} is called.  If the function is a
6158 lambda list, @code{funcall_lambda()} is called.  If the function is a
6159 macro, [..... fill in] is done.  If the function is an autoload,
6160 @code{do_autoload()} is called to load the definition and then eval
6161 starts over [explain this more].
6162
6163 When @code{Feval()} exits, the evaluation depth is reduced by one, the
6164 debugger is called if appropriate, and the current backtrace structure
6165 is removed from the list.
6166
6167 Both @code{funcall_compiled_function()} and @code{funcall_lambda()} need
6168 to go through the list of formal parameters to the function and bind
6169 them to the actual arguments, checking for @code{&rest} and
6170 @code{&optional} symbols in the formal parameters and making sure the
6171 number of actual arguments is correct.
6172 @code{funcall_compiled_function()} can do this a little more
6173 efficiently, since the formal parameter list can be checked for sanity
6174 when the compiled function object is created.
6175
6176 @code{funcall_lambda()} simply calls @code{Fprogn} to execute the code
6177 in the lambda list.
6178
6179 @code{funcall_compiled_function()} calls the real byte-code interpreter
6180 @code{execute_optimized_program()} on the byte-code instructions, which
6181 are converted into an internal form for faster execution.
6182
6183 When a compiled function is executed for the first time by
6184 @code{funcall_compiled_function()}, or when it is @code{Fpurecopy()}ed
6185 during the dump phase of building XEmacs, the byte-code instructions are
6186 converted from a @code{Lisp_String} (which is inefficient to access,
6187 especially in the presence of MULE) into a @code{Lisp_Opaque} object
6188 containing an array of unsigned char, which can be directly executed by
6189 the byte-code interpreter.  At this time the byte code is also analyzed
6190 for validity and transformed into a more optimized form, so that
6191 @code{execute_optimized_program()} can really fly.
6192
6193 Here are some of the optimizations performed by the internal byte-code
6194 transformer:
6195 @enumerate
6196 @item
6197 References to the @code{constants} array are checked for out-of-range
6198 indices, so that the byte interpreter doesn't have to.
6199 @item
6200 References to the @code{constants} array that will be used as a Lisp
6201 variable are checked for being correct non-constant (i.e. not @code{t},
6202 @code{nil}, or @code{keywordp}) symbols, so that the byte interpreter
6203 doesn't have to.
6204 @item
6205 The maxiumum number of variable bindings in the byte-code is
6206 pre-computed, so that space on the @code{specpdl} stack can be
6207 pre-reserved once for the whole function execution.
6208 @item
6209 All byte-code jumps are relative to the current program counter instead
6210 of the start of the program, thereby saving a register.
6211 @item
6212 One-byte relative jumps are converted from the byte-code form of unsigned
6213 chars offset by 127 to machine-friendly signed chars.
6214 @end enumerate
6215
6216 Of course, this transformation of the @code{instructions} should not be
6217 visible to the user, so @code{Fcompiled_function_instructions()} needs
6218 to know how to convert the optimized opaque object back into a Lisp
6219 string that is identical to the original string from the @file{.elc}
6220 file.  (Actually, the resulting string may (rarely) contain slightly
6221 different, yet equivalent, byte code.)
6222
6223 @code{Ffuncall()} implements Lisp @code{funcall}.  @code{(funcall fun
6224 x1 x2 x3 ...)} is equivalent to @code{(eval (list fun (quote x1) (quote
6225 x2) (quote x3) ...))}.  @code{Ffuncall()} contains its own code to do
6226 the evaluation, however, and is very similar to @code{Feval()}.
6227
6228 From the performance point of view, it is worth knowing that most of the
6229 time in Lisp evaluation is spent executing @code{Lisp_Subr} and
6230 @code{Lisp_Compiled_Function} objects via @code{Ffuncall()} (not
6231 @code{Feval()}).
6232
6233 @code{Fapply()} implements Lisp @code{apply}, which is very similar to
6234 @code{funcall} except that if the last argument is a list, the result is the
6235 same as if each of the arguments in the list had been passed separately.
6236 @code{Fapply()} does some business to expand the last argument if it's a
6237 list, then calls @code{Ffuncall()} to do the work.
6238
6239 @code{apply1()}, @code{call0()}, @code{call1()}, @code{call2()}, and
6240 @code{call3()} call a function, passing it the argument(s) given (the
6241 arguments are given as separate C arguments rather than being passed as
6242 an array).  @code{apply1()} uses @code{Fapply()} while the others use
6243 @code{Ffuncall()} to do the real work.
6244
6245 @node Dynamic Binding; The specbinding Stack; Unwind-Protects
6246 @section Dynamic Binding; The specbinding Stack; Unwind-Protects
6247
6248 @example
6249 struct specbinding
6250 @{
6251   Lisp_Object symbol;
6252   Lisp_Object old_value;
6253   Lisp_Object (*func) (Lisp_Object); /* for unwind-protect */
6254 @};
6255 @end example
6256
6257   @code{struct specbinding} is used for local-variable bindings and
6258 unwind-protects.  @code{specpdl} holds an array of @code{struct specbinding}'s,
6259 @code{specpdl_ptr} points to the beginning of the free bindings in the
6260 array, @code{specpdl_size} specifies the total number of binding slots
6261 in the array, and @code{max_specpdl_size} specifies the maximum number
6262 of bindings the array can be expanded to hold.  @code{grow_specpdl()}
6263 increases the size of the @code{specpdl} array, multiplying its size by
6264 2 but never exceeding @code{max_specpdl_size} (except that if this
6265 number is less than 400, it is first set to 400).
6266
6267   @code{specbind()} binds a symbol to a value and is used for local
6268 variables and @code{let} forms.  The symbol and its old value (which
6269 might be @code{Qunbound}, indicating no prior value) are recorded in the
6270 specpdl array, and @code{specpdl_size} is increased by 1.
6271
6272   @code{record_unwind_protect()} implements an @dfn{unwind-protect},
6273 which, when placed around a section of code, ensures that some specified
6274 cleanup routine will be executed even if the code exits abnormally
6275 (e.g. through a @code{throw} or quit).  @code{record_unwind_protect()}
6276 simply adds a new specbinding to the @code{specpdl} array and stores the
6277 appropriate information in it.  The cleanup routine can either be a C
6278 function, which is stored in the @code{func} field, or a @code{progn}
6279 form, which is stored in the @code{old_value} field.
6280
6281   @code{unbind_to()} removes specbindings from the @code{specpdl} array
6282 until the specified position is reached.  Each specbinding can be one of
6283 three types:
6284
6285 @enumerate
6286 @item
6287 an unwind-protect with a C cleanup function (@code{func} is not 0, and
6288 @code{old_value} holds an argument to be passed to the function);
6289 @item
6290 an unwind-protect with a Lisp form (@code{func} is 0, @code{symbol}
6291 is @code{nil}, and @code{old_value} holds the form to be executed with
6292 @code{Fprogn()}); or
6293 @item
6294 a local-variable binding (@code{func} is 0, @code{symbol} is not
6295 @code{nil}, and @code{old_value} holds the old value, which is stored as
6296 the symbol's value).
6297 @end enumerate
6298
6299 @node Simple Special Forms
6300 @section Simple Special Forms
6301
6302 @code{or}, @code{and}, @code{if}, @code{cond}, @code{progn},
6303 @code{prog1}, @code{prog2}, @code{setq}, @code{quote}, @code{function},
6304 @code{let*}, @code{let}, @code{while}
6305
6306 All of these are very simple and work as expected, calling
6307 @code{Feval()} or @code{Fprogn()} as necessary and (in the case of
6308 @code{let} and @code{let*}) using @code{specbind()} to create bindings
6309 and @code{unbind_to()} to undo the bindings when finished.
6310
6311 Note that, with the exeption of @code{Fprogn}, these functions are
6312 typically called in real life only in interpreted code, since the byte
6313 compiler knows how to convert calls to these functions directly into
6314 byte code.
6315
6316 @node Catch and Throw
6317 @section Catch and Throw
6318
6319 @example
6320 struct catchtag
6321 @{
6322   Lisp_Object tag;
6323   Lisp_Object val;
6324   struct catchtag *next;
6325   struct gcpro *gcpro;
6326   jmp_buf jmp;
6327   struct backtrace *backlist;
6328   int lisp_eval_depth;
6329   int pdlcount;
6330 @};
6331 @end example
6332
6333   @code{catch} is a Lisp function that places a catch around a body of
6334 code.  A catch is a means of non-local exit from the code.  When a catch
6335 is created, a tag is specified, and executing a @code{throw} to this tag
6336 will exit from the body of code caught with this tag, and its value will
6337 be the value given in the call to @code{throw}.  If there is no such
6338 call, the code will be executed normally.
6339
6340   Information pertaining to a catch is held in a @code{struct catchtag},
6341 which is placed at the head of a linked list pointed to by
6342 @code{catchlist}.  @code{internal_catch()} is passed a C function to
6343 call (@code{Fprogn()} when Lisp @code{catch} is called) and arguments to
6344 give it, and places a catch around the function.  Each @code{struct
6345 catchtag} is held in the stack frame of the @code{internal_catch()}
6346 instance that created the catch.
6347
6348   @code{internal_catch()} is fairly straightforward.  It stores into the
6349 @code{struct catchtag} the tag name and the current values of
6350 @code{backtrace_list}, @code{lisp_eval_depth}, @code{gcprolist}, and the
6351 offset into the @code{specpdl} array, sets a jump point with @code{_setjmp()}
6352 (storing the jump point into the @code{struct catchtag}), and calls the
6353 function.  Control will return to @code{internal_catch()} either when
6354 the function exits normally or through a @code{_longjmp()} to this jump
6355 point.  In the latter case, @code{throw} will store the value to be
6356 returned into the @code{struct catchtag} before jumping.  When it's
6357 done, @code{internal_catch()} removes the @code{struct catchtag} from
6358 the catchlist and returns the proper value.
6359
6360   @code{Fthrow()} goes up through the catchlist until it finds one with
6361 a matching tag.  It then calls @code{unbind_catch()} to restore
6362 everything to what it was when the appropriate catch was set, stores the
6363 return value in the @code{struct catchtag}, and jumps (with
6364 @code{_longjmp()}) to its jump point.
6365
6366   @code{unbind_catch()} removes all catches from the catchlist until it
6367 finds the correct one.  Some of the catches might have been placed for
6368 error-trapping, and if so, the appropriate entries on the handlerlist
6369 must be removed (see ``errors'').  @code{unbind_catch()} also restores
6370 the values of @code{gcprolist}, @code{backtrace_list}, and
6371 @code{lisp_eval}, and calls @code{unbind_to()} to undo any specbindings
6372 created since the catch.
6373
6374
6375 @node Symbols and Variables, Buffers and Textual Representation, Evaluation; Stack Frames; Bindings, Top
6376 @chapter Symbols and Variables
6377
6378 @menu
6379 * Introduction to Symbols::
6380 * Obarrays::
6381 * Symbol Values::
6382 @end menu
6383
6384 @node Introduction to Symbols
6385 @section Introduction to Symbols
6386
6387   A symbol is basically just an object with four fields: a name (a
6388 string), a value (some Lisp object), a function (some Lisp object), and
6389 a property list (usually a list of alternating keyword/value pairs).
6390 What makes symbols special is that there is usually only one symbol with
6391 a given name, and the symbol is referred to by name.  This makes a
6392 symbol a convenient way of calling up data by name, i.e. of implementing
6393 variables. (The variable's value is stored in the @dfn{value slot}.)
6394 Similarly, functions are referenced by name, and the definition of the
6395 function is stored in a symbol's @dfn{function slot}.  This means that
6396 there can be a distinct function and variable with the same name.  The
6397 property list is used as a more general mechanism of associating
6398 additional values with particular names, and once again the namespace is
6399 independent of the function and variable namespaces.
6400
6401 @node Obarrays
6402 @section Obarrays
6403
6404   The identity of symbols with their names is accomplished through a
6405 structure called an obarray, which is just a poorly-implemented hash
6406 table mapping from strings to symbols whose name is that string. (I say
6407 ``poorly implemented'' because an obarray appears in Lisp as a vector
6408 with some hidden fields rather than as its own opaque type.  This is an
6409 Emacs Lisp artifact that should be fixed.)
6410
6411   Obarrays are implemented as a vector of some fixed size (which should
6412 be a prime for best results), where each ``bucket'' of the vector
6413 contains one or more symbols, threaded through a hidden @code{next}
6414 field in the symbol.  Lookup of a symbol in an obarray, and adding a
6415 symbol to an obarray, is accomplished through standard hash-table
6416 techniques.
6417
6418   The standard Lisp function for working with symbols and obarrays is
6419 @code{intern}.  This looks up a symbol in an obarray given its name; if
6420 it's not found, a new symbol is automatically created with the specified
6421 name, added to the obarray, and returned.  This is what happens when the
6422 Lisp reader encounters a symbol (or more precisely, encounters the name
6423 of a symbol) in some text that it is reading.  There is a standard
6424 obarray called @code{obarray} that is used for this purpose, although
6425 the Lisp programmer is free to create his own obarrays and @code{intern}
6426 symbols in them.
6427
6428   Note that, once a symbol is in an obarray, it stays there until
6429 something is done about it, and the standard obarray @code{obarray}
6430 always stays around, so once you use any particular variable name, a
6431 corresponding symbol will stay around in @code{obarray} until you exit
6432 XEmacs.
6433
6434   Note that @code{obarray} itself is a variable, and as such there is a
6435 symbol in @code{obarray} whose name is @code{"obarray"} and which
6436 contains @code{obarray} as its value.
6437
6438   Note also that this call to @code{intern} occurs only when in the Lisp
6439 reader, not when the code is executed (at which point the symbol is
6440 already around, stored as such in the definition of the function).
6441
6442   You can create your own obarray using @code{make-vector} (this is
6443 horrible but is an artifact) and intern symbols into that obarray.
6444 Doing that will result in two or more symbols with the same name.
6445 However, at most one of these symbols is in the standard @code{obarray}:
6446 You cannot have two symbols of the same name in any particular obarray.
6447 Note that you cannot add a symbol to an obarray in any fashion other
6448 than using @code{intern}: i.e. you can't take an existing symbol and put
6449 it in an existing obarray.  Nor can you change the name of an existing
6450 symbol. (Since obarrays are vectors, you can violate the consistency of
6451 things by storing directly into the vector, but let's ignore that
6452 possibility.)
6453
6454   Usually symbols are created by @code{intern}, but if you really want,
6455 you can explicitly create a symbol using @code{make-symbol}, giving it
6456 some name.  The resulting symbol is not in any obarray (i.e. it is
6457 @dfn{uninterned}), and you can't add it to any obarray.  Therefore its
6458 primary purpose is as a symbol to use in macros to avoid namespace
6459 pollution.  It can also be used as a carrier of information, but cons
6460 cells could probably be used just as well.
6461
6462   You can also use @code{intern-soft} to look up a symbol but not create
6463 a new one, and @code{unintern} to remove a symbol from an obarray.  This
6464 returns the removed symbol. (Remember: You can't put the symbol back
6465 into any obarray.) Finally, @code{mapatoms} maps over all of the symbols
6466 in an obarray.
6467
6468 @node Symbol Values
6469 @section Symbol Values
6470
6471   The value field of a symbol normally contains a Lisp object.  However,
6472 a symbol can be @dfn{unbound}, meaning that it logically has no value.
6473 This is internally indicated by storing a special Lisp object, called
6474 @dfn{the unbound marker} and stored in the global variable
6475 @code{Qunbound}.  The unbound marker is of a special Lisp object type
6476 called @dfn{symbol-value-magic}.  It is impossible for the Lisp
6477 programmer to directly create or access any object of this type.
6478
6479   @strong{You must not let any ``symbol-value-magic'' object escape to
6480 the Lisp level.}  Printing any of these objects will cause the message
6481 @samp{INTERNAL EMACS BUG} to appear as part of the print representation.
6482 (You may see this normally when you call @code{debug_print()} from the
6483 debugger on a Lisp object.) If you let one of these objects escape to
6484 the Lisp level, you will violate a number of assumptions contained in
6485 the C code and make the unbound marker not function right.
6486
6487   When a symbol is created, its value field (and function field) are set
6488 to @code{Qunbound}.  The Lisp programmer can restore these conditions
6489 later using @code{makunbound} or @code{fmakunbound}, and can query to
6490 see whether the value of function fields are @dfn{bound} (i.e. have a
6491 value other than @code{Qunbound}) using @code{boundp} and
6492 @code{fboundp}.  The fields are set to a normal Lisp object using
6493 @code{set} (or @code{setq}) and @code{fset}.
6494
6495   Other symbol-value-magic objects are used as special markers to
6496 indicate variables that have non-normal properties.  This includes any
6497 variables that are tied into C variables (setting the variable magically
6498 sets some global variable in the C code, and likewise for retrieving the
6499 variable's value), variables that magically tie into slots in the
6500 current buffer, variables that are buffer-local, etc.  The
6501 symbol-value-magic object is stored in the value cell in place of
6502 a normal object, and the code to retrieve a symbol's value
6503 (i.e. @code{symbol-value}) knows how to do special things with them.
6504 This means that you should not just fetch the value cell directly if you
6505 want a symbol's value.
6506
6507   The exact workings of this are rather complex and involved and are
6508 well-documented in comments in @file{buffer.c}, @file{symbols.c}, and
6509 @file{lisp.h}.
6510
6511 @node Buffers and Textual Representation, MULE Character Sets and Encodings, Symbols and Variables, Top
6512 @chapter Buffers and Textual Representation
6513
6514 @menu
6515 * Introduction to Buffers::     A buffer holds a block of text such as a file.
6516 * The Text in a Buffer::        Representation of the text in a buffer.
6517 * Buffer Lists::                Keeping track of all buffers.
6518 * Markers and Extents::         Tagging locations within a buffer.
6519 * Bufbytes and Emchars::        Representation of individual characters.
6520 * The Buffer Object::           The Lisp object corresponding to a buffer.
6521 @end menu
6522
6523 @node Introduction to Buffers
6524 @section Introduction to Buffers
6525
6526   A buffer is logically just a Lisp object that holds some text.
6527 In this, it is like a string, but a buffer is optimized for
6528 frequent insertion and deletion, while a string is not.  Furthermore:
6529
6530 @enumerate
6531 @item
6532 Buffers are @dfn{permanent} objects, i.e. once you create them, they
6533 remain around, and need to be explicitly deleted before they go away.
6534 @item
6535 Each buffer has a unique name, which is a string.  Buffers are
6536 normally referred to by name.  In this respect, they are like
6537 symbols.
6538 @item
6539 Buffers have a default insertion position, called @dfn{point}.
6540 Inserting text (unless you explicitly give a position) goes at point,
6541 and moves point forward past the text.  This is what is going on when
6542 you type text into Emacs.
6543 @item
6544 Buffers have lots of extra properties associated with them.
6545 @item
6546 Buffers can be @dfn{displayed}.  What this means is that there
6547 exist a number of @dfn{windows}, which are objects that correspond
6548 to some visible section of your display, and each window has
6549 an associated buffer, and the current contents of the buffer
6550 are shown in that section of the display.  The redisplay mechanism
6551 (which takes care of doing this) knows how to look at the
6552 text of a buffer and come up with some reasonable way of displaying
6553 this.  Many of the properties of a buffer control how the
6554 buffer's text is displayed.
6555 @item
6556 One buffer is distinguished and called the @dfn{current buffer}.  It is
6557 stored in the variable @code{current_buffer}.  Buffer operations operate
6558 on this buffer by default.  When you are typing text into a buffer, the
6559 buffer you are typing into is always @code{current_buffer}.  Switching
6560 to a different window changes the current buffer.  Note that Lisp code
6561 can temporarily change the current buffer using @code{set-buffer} (often
6562 enclosed in a @code{save-excursion} so that the former current buffer
6563 gets restored when the code is finished).  However, calling
6564 @code{set-buffer} will NOT cause a permanent change in the current
6565 buffer.  The reason for this is that the top-level event loop sets
6566 @code{current_buffer} to the buffer of the selected window, each time
6567 it finishes executing a user command.
6568 @end enumerate
6569
6570   Make sure you understand the distinction between @dfn{current buffer}
6571 and @dfn{buffer of the selected window}, and the distinction between
6572 @dfn{point} of the current buffer and @dfn{window-point} of the selected
6573 window. (This latter distinction is explained in detail in the section
6574 on windows.)
6575
6576 @node The Text in a Buffer
6577 @section The Text in a Buffer
6578
6579   The text in a buffer consists of a sequence of zero or more
6580 characters.  A @dfn{character} is an integer that logically represents
6581 a letter, number, space, or other unit of text.  Most of the characters
6582 that you will typically encounter belong to the ASCII set of characters,
6583 but there are also characters for various sorts of accented letters,
6584 special symbols, Chinese and Japanese ideograms (i.e. Kanji, Katakana,
6585 etc.), Cyrillic and Greek letters, etc.  The actual number of possible
6586 characters is quite large.
6587
6588   For now, we can view a character as some non-negative integer that
6589 has some shape that defines how it typically appears (e.g. as an
6590 uppercase A). (The exact way in which a character appears depends on the
6591 font used to display the character.) The internal type of characters in
6592 the C code is an @code{Emchar}; this is just an @code{int}, but using a
6593 symbolic type makes the code clearer.
6594
6595   Between every character in a buffer is a @dfn{buffer position} or
6596 @dfn{character position}.  We can speak of the character before or after
6597 a particular buffer position, and when you insert a character at a
6598 particular position, all characters after that position end up at new
6599 positions.  When we speak of the character @dfn{at} a position, we
6600 really mean the character after the position.  (This schizophrenia
6601 between a buffer position being ``between'' a character and ``on'' a
6602 character is rampant in Emacs.)
6603
6604   Buffer positions are numbered starting at 1.  This means that
6605 position 1 is before the first character, and position 0 is not
6606 valid.  If there are N characters in a buffer, then buffer
6607 position N+1 is after the last one, and position N+2 is not valid.
6608
6609   The internal makeup of the Emchar integer varies depending on whether
6610 we have compiled with MULE support.  If not, the Emchar integer is an
6611 8-bit integer with possible values from 0 - 255.  0 - 127 are the
6612 standard ASCII characters, while 128 - 255 are the characters from the
6613 ISO-8859-1 character set.  If we have compiled with MULE support, an
6614 Emchar is a 19-bit integer, with the various bits having meanings
6615 according to a complex scheme that will be detailed later.  The
6616 characters numbered 0 - 255 still have the same meanings as for the
6617 non-MULE case, though.
6618
6619   Internally, the text in a buffer is represented in a fairly simple
6620 fashion: as a contiguous array of bytes, with a @dfn{gap} of some size
6621 in the middle.  Although the gap is of some substantial size in bytes,
6622 there is no text contained within it: From the perspective of the text
6623 in the buffer, it does not exist.  The gap logically sits at some buffer
6624 position, between two characters (or possibly at the beginning or end of
6625 the buffer).  Insertion of text in a buffer at a particular position is
6626 always accomplished by first moving the gap to that position
6627 (i.e. through some block moving of text), then writing the text into the
6628 beginning of the gap, thereby shrinking the gap.  If the gap shrinks
6629 down to nothing, a new gap is created. (What actually happens is that a
6630 new gap is ``created'' at the end of the buffer's text, which requires
6631 nothing more than changing a couple of indices; then the gap is
6632 ``moved'' to the position where the insertion needs to take place by
6633 moving up in memory all the text after that position.)  Similarly,
6634 deletion occurs by moving the gap to the place where the text is to be
6635 deleted, and then simply expanding the gap to include the deleted text.
6636 (@dfn{Expanding} and @dfn{shrinking} the gap as just described means
6637 just that the internal indices that keep track of where the gap is
6638 located are changed.)
6639
6640   Note that the total amount of memory allocated for a buffer text never
6641 decreases while the buffer is live.  Therefore, if you load up a
6642 20-megabyte file and then delete all but one character, there will be a
6643 20-megabyte gap, which won't get any smaller (except by inserting
6644 characters back again).  Once the buffer is killed, the memory allocated
6645 for the buffer text will be freed, but it will still be sitting on the
6646 heap, taking up virtual memory, and will not be released back to the
6647 operating system. (However, if you have compiled XEmacs with rel-alloc,
6648 the situation is different.  In this case, the space @emph{will} be
6649 released back to the operating system.  However, this tends to result in a
6650 noticeable speed penalty.)
6651
6652   Astute readers may notice that the text in a buffer is represented as
6653 an array of @emph{bytes}, while (at least in the MULE case) an Emchar is
6654 a 19-bit integer, which clearly cannot fit in a byte.  This means (of
6655 course) that the text in a buffer uses a different representation from
6656 an Emchar: specifically, the 19-bit Emchar becomes a series of one to
6657 four bytes.  The conversion between these two representations is complex
6658 and will be described later.
6659
6660   In the non-MULE case, everything is very simple: An Emchar
6661 is an 8-bit value, which fits neatly into one byte.
6662
6663   If we are given a buffer position and want to retrieve the
6664 character at that position, we need to follow these steps:
6665
6666 @enumerate
6667 @item
6668 Pretend there's no gap, and convert the buffer position into a @dfn{byte
6669 index} that indexes to the appropriate byte in the buffer's stream of
6670 textual bytes.  By convention, byte indices begin at 1, just like buffer
6671 positions.  In the non-MULE case, byte indices and buffer positions are
6672 identical, since one character equals one byte.
6673 @item
6674 Convert the byte index into a @dfn{memory index}, which takes the gap
6675 into account.  The memory index is a direct index into the block of
6676 memory that stores the text of a buffer.  This basically just involves
6677 checking to see if the byte index is past the gap, and if so, adding the
6678 size of the gap to it.  By convention, memory indices begin at 1, just
6679 like buffer positions and byte indices, and when referring to the
6680 position that is @dfn{at} the gap, we always use the memory position at
6681 the @emph{beginning}, not at the end, of the gap.
6682 @item
6683 Fetch the appropriate bytes at the determined memory position.
6684 @item
6685 Convert these bytes into an Emchar.
6686 @end enumerate
6687
6688   In the non-Mule case, (3) and (4) boil down to a simple one-byte
6689 memory access.
6690
6691   Note that we have defined three types of positions in a buffer:
6692
6693 @enumerate
6694 @item
6695 @dfn{buffer positions} or @dfn{character positions}, typedef @code{Bufpos}
6696 @item
6697 @dfn{byte indices}, typedef @code{Bytind}
6698 @item
6699 @dfn{memory indices}, typedef @code{Memind}
6700 @end enumerate
6701
6702   All three typedefs are just @code{int}s, but defining them this way makes
6703 things a lot clearer.
6704
6705   Most code works with buffer positions.  In particular, all Lisp code
6706 that refers to text in a buffer uses buffer positions.  Lisp code does
6707 not know that byte indices or memory indices exist.
6708
6709   Finally, we have a typedef for the bytes in a buffer.  This is a
6710 @code{Bufbyte}, which is an unsigned char.  Referring to them as
6711 Bufbytes underscores the fact that we are working with a string of bytes
6712 in the internal Emacs buffer representation rather than in one of a
6713 number of possible alternative representations (e.g. EUC-encoded text,
6714 etc.).
6715
6716 @node Buffer Lists
6717 @section Buffer Lists
6718
6719   Recall earlier that buffers are @dfn{permanent} objects, i.e.  that
6720 they remain around until explicitly deleted.  This entails that there is
6721 a list of all the buffers in existence.  This list is actually an
6722 assoc-list (mapping from the buffer's name to the buffer) and is stored
6723 in the global variable @code{Vbuffer_alist}.
6724
6725   The order of the buffers in the list is important: the buffers are
6726 ordered approximately from most-recently-used to least-recently-used.
6727 Switching to a buffer using @code{switch-to-buffer},
6728 @code{pop-to-buffer}, etc. and switching windows using
6729 @code{other-window}, etc.  usually brings the new current buffer to the
6730 front of the list.  @code{switch-to-buffer}, @code{other-buffer},
6731 etc. look at the beginning of the list to find an alternative buffer to
6732 suggest.  You can also explicitly move a buffer to the end of the list
6733 using @code{bury-buffer}.
6734
6735   In addition to the global ordering in @code{Vbuffer_alist}, each frame
6736 has its own ordering of the list.  These lists always contain the same
6737 elements as in @code{Vbuffer_alist} although possibly in a different
6738 order.  @code{buffer-list} normally returns the list for the selected
6739 frame.  This allows you to work in separate frames without things
6740 interfering with each other.
6741
6742   The standard way to look up a buffer given a name is
6743 @code{get-buffer}, and the standard way to create a new buffer is
6744 @code{get-buffer-create}, which looks up a buffer with a given name,
6745 creating a new one if necessary.  These operations correspond exactly
6746 with the symbol operations @code{intern-soft} and @code{intern},
6747 respectively.  You can also force a new buffer to be created using
6748 @code{generate-new-buffer}, which takes a name and (if necessary) makes
6749 a unique name from this by appending a number, and then creates the
6750 buffer.  This is basically like the symbol operation @code{gensym}.
6751
6752 @node Markers and Extents
6753 @section Markers and Extents
6754
6755   Among the things associated with a buffer are things that are
6756 logically attached to certain buffer positions.  This can be used to
6757 keep track of a buffer position when text is inserted and deleted, so
6758 that it remains at the same spot relative to the text around it; to
6759 assign properties to particular sections of text; etc.  There are two
6760 such objects that are useful in this regard: they are @dfn{markers} and
6761 @dfn{extents}.
6762
6763   A @dfn{marker} is simply a flag placed at a particular buffer
6764 position, which is moved around as text is inserted and deleted.
6765 Markers are used for all sorts of purposes, such as the @code{mark} that
6766 is the other end of textual regions to be cut, copied, etc.
6767
6768   An @dfn{extent} is similar to two markers plus some associated
6769 properties, and is used to keep track of regions in a buffer as text is
6770 inserted and deleted, and to add properties (e.g. fonts) to particular
6771 regions of text.  The external interface of extents is explained
6772 elsewhere.
6773
6774   The important thing here is that markers and extents simply contain
6775 buffer positions in them as integers, and every time text is inserted or
6776 deleted, these positions must be updated.  In order to minimize the
6777 amount of shuffling that needs to be done, the positions in markers and
6778 extents (there's one per marker, two per extent) and stored in Meminds.
6779 This means that they only need to be moved when the text is physically
6780 moved in memory; since the gap structure tries to minimize this, it also
6781 minimizes the number of marker and extent indices that need to be
6782 adjusted.  Look in @file{insdel.c} for the details of how this works.
6783
6784   One other important distinction is that markers are @dfn{temporary}
6785 while extents are @dfn{permanent}.  This means that markers disappear as
6786 soon as there are no more pointers to them, and correspondingly, there
6787 is no way to determine what markers are in a buffer if you are just
6788 given the buffer.  Extents remain in a buffer until they are detached
6789 (which could happen as a result of text being deleted) or the buffer is
6790 deleted, and primitives do exist to enumerate the extents in a buffer.
6791
6792 @node Bufbytes and Emchars
6793 @section Bufbytes and Emchars
6794
6795   Not yet documented.
6796
6797 @node The Buffer Object
6798 @section The Buffer Object
6799
6800   Buffers contain fields not directly accessible by the Lisp programmer.
6801 We describe them here, naming them by the names used in the C code.
6802 Many are accessible indirectly in Lisp programs via Lisp primitives.
6803
6804 @table @code
6805 @item name
6806 The buffer name is a string that names the buffer.  It is guaranteed to
6807 be unique.  @xref{Buffer Names,,, lispref, XEmacs Lisp Programmer's
6808 Manual}.
6809
6810 @item save_modified
6811 This field contains the time when the buffer was last saved, as an
6812 integer.  @xref{Buffer Modification,,, lispref, XEmacs Lisp Programmer's
6813 Manual}.
6814
6815 @item modtime
6816 This field contains the modification time of the visited file.  It is
6817 set when the file is written or read.  Every time the buffer is written
6818 to the file, this field is compared to the modification time of the
6819 file.  @xref{Buffer Modification,,, lispref, XEmacs Lisp Programmer's
6820 Manual}.
6821
6822 @item auto_save_modified
6823 This field contains the time when the buffer was last auto-saved.
6824
6825 @item last_window_start
6826 This field contains the @code{window-start} position in the buffer as of
6827 the last time the buffer was displayed in a window.
6828
6829 @item undo_list
6830 This field points to the buffer's undo list.  @xref{Undo,,, lispref,
6831 XEmacs Lisp Programmer's Manual}.
6832
6833 @item syntax_table_v
6834 This field contains the syntax table for the buffer.  @xref{Syntax
6835 Tables,,, lispref, XEmacs Lisp Programmer's Manual}.
6836
6837 @item downcase_table
6838 This field contains the conversion table for converting text to lower
6839 case.  @xref{Case Tables,,, lispref, XEmacs Lisp Programmer's Manual}.
6840
6841 @item upcase_table
6842 This field contains the conversion table for converting text to upper
6843 case.  @xref{Case Tables,,, lispref, XEmacs Lisp Programmer's Manual}.
6844
6845 @item case_canon_table
6846 This field contains the conversion table for canonicalizing text for
6847 case-folding search.  @xref{Case Tables,,, lispref, XEmacs Lisp
6848 Programmer's Manual}.
6849
6850 @item case_eqv_table
6851 This field contains the equivalence table for case-folding search.
6852 @xref{Case Tables,,, lispref, XEmacs Lisp Programmer's Manual}.
6853
6854 @item display_table
6855 This field contains the buffer's display table, or @code{nil} if it
6856 doesn't have one.  @xref{Display Tables,,, lispref, XEmacs Lisp
6857 Programmer's Manual}.
6858
6859 @item markers
6860 This field contains the chain of all markers that currently point into
6861 the buffer.  Deletion of text in the buffer, and motion of the buffer's
6862 gap, must check each of these markers and perhaps update it.
6863 @xref{Markers,,, lispref, XEmacs Lisp Programmer's Manual}.
6864
6865 @item backed_up
6866 This field is a flag that tells whether a backup file has been made for
6867 the visited file of this buffer.
6868
6869 @item mark
6870 This field contains the mark for the buffer.  The mark is a marker,
6871 hence it is also included on the list @code{markers}.  @xref{The Mark,,,
6872 lispref, XEmacs Lisp Programmer's Manual}.
6873
6874 @item mark_active
6875 This field is non-@code{nil} if the buffer's mark is active.
6876
6877 @item local_var_alist
6878 This field contains the association list describing the variables local
6879 in this buffer, and their values, with the exception of local variables
6880 that have special slots in the buffer object.  (Those slots are omitted
6881 from this table.)  @xref{Buffer-Local Variables,,, lispref, XEmacs Lisp
6882 Programmer's Manual}.
6883
6884 @item modeline_format
6885 This field contains a Lisp object which controls how to display the mode
6886 line for this buffer.  @xref{Modeline Format,,, lispref, XEmacs Lisp
6887 Programmer's Manual}.
6888
6889 @item base_buffer
6890 This field holds the buffer's base buffer (if it is an indirect buffer),
6891 or @code{nil}.
6892 @end table
6893
6894 @node MULE Character Sets and Encodings, The Lisp Reader and Compiler, Buffers and Textual Representation, Top
6895 @chapter MULE Character Sets and Encodings
6896
6897   Recall that there are two primary ways that text is represented in
6898 XEmacs.  The @dfn{buffer} representation sees the text as a series of
6899 bytes (Bufbytes), with a variable number of bytes used per character.
6900 The @dfn{character} representation sees the text as a series of integers
6901 (Emchars), one per character.  The character representation is a cleaner
6902 representation from a theoretical standpoint, and is thus used in many
6903 cases when lots of manipulations on a string need to be done.  However,
6904 the buffer representation is the standard representation used in both
6905 Lisp strings and buffers, and because of this, it is the ``default''
6906 representation that text comes in.  The reason for using this
6907 representation is that it's compact and is compatible with ASCII.
6908
6909 @menu
6910 * Character Sets::
6911 * Encodings::
6912 * Internal Mule Encodings::
6913 * CCL::
6914 @end menu
6915
6916 @node Character Sets
6917 @section Character Sets
6918
6919   A character set (or @dfn{charset}) is an ordered set of characters.  A
6920 particular character in a charset is indexed using one or more
6921 @dfn{position codes}, which are non-negative integers.  The number of
6922 position codes needed to identify a particular character in a charset is
6923 called the @dfn{dimension} of the charset.  In XEmacs/Mule, all charsets
6924 have dimension 1 or 2, and the size of all charsets (except for a few
6925 special cases) is either 94, 96, 94 by 94, or 96 by 96.  The range of
6926 position codes used to index characters from any of these types of
6927 character sets is as follows:
6928
6929 @example
6930 Charset type            Position code 1         Position code 2
6931 ------------------------------------------------------------
6932 94                      33 - 126                N/A
6933 96                      32 - 127                N/A
6934 94x94                   33 - 126                33 - 126
6935 96x96                   32 - 127                32 - 127
6936 @end example
6937
6938   Note that in the above cases position codes do not start at an
6939 expected value such as 0 or 1.  The reason for this will become clear
6940 later.
6941
6942   For example, Latin-1 is a 96-character charset, and JISX0208 (the
6943 Japanese national character set) is a 94x94-character charset.
6944
6945   [Note that, although the ranges above define the @emph{valid} position
6946 codes for a charset, some of the slots in a particular charset may in
6947 fact be empty.  This is the case for JISX0208, for example, where (e.g.)
6948 all the slots whose first position code is in the range 118 - 127 are
6949 empty.]
6950
6951   There are three charsets that do not follow the above rules.  All of
6952 them have one dimension, and have ranges of position codes as follows:
6953
6954 @example
6955 Charset name            Position code 1
6956 ------------------------------------
6957 ASCII                   0 - 127
6958 Control-1               0 - 31
6959 Composite               0 - some large number
6960 @end example
6961
6962   (The upper bound of the position code for composite characters has not
6963 yet been determined, but it will probably be at least 16,383).
6964
6965   ASCII is the union of two subsidiary character sets: Printing-ASCII
6966 (the printing ASCII character set, consisting of position codes 33 -
6967 126, like for a standard 94-character charset) and Control-ASCII (the
6968 non-printing characters that would appear in a binary file with codes 0
6969 - 32 and 127).
6970
6971   Control-1 contains the non-printing characters that would appear in a
6972 binary file with codes 128 - 159.
6973
6974   Composite contains characters that are generated by overstriking one
6975 or more characters from other charsets.
6976
6977   Note that some characters in ASCII, and all characters in Control-1,
6978 are @dfn{control} (non-printing) characters.  These have no printed
6979 representation but instead control some other function of the printing
6980 (e.g. TAB or 8 moves the current character position to the next tab
6981 stop).  All other characters in all charsets are @dfn{graphic}
6982 (printing) characters.
6983
6984   When a binary file is read in, the bytes in the file are assigned to
6985 character sets as follows:
6986
6987 @example
6988 Bytes           Character set           Range
6989 --------------------------------------------------
6990 0 - 127         ASCII                   0 - 127
6991 128 - 159       Control-1               0 - 31
6992 160 - 255       Latin-1                 32 - 127
6993 @end example
6994
6995   This is a bit ad-hoc but gets the job done.
6996
6997 @node Encodings
6998 @section Encodings
6999
7000   An @dfn{encoding} is a way of numerically representing characters from
7001 one or more character sets.  If an encoding only encompasses one
7002 character set, then the position codes for the characters in that
7003 character set could be used directly.  This is not possible, however, if
7004 more than one character set is to be used in the encoding.
7005
7006   For example, the conversion detailed above between bytes in a binary
7007 file and characters is effectively an encoding that encompasses the
7008 three character sets ASCII, Control-1, and Latin-1 in a stream of 8-bit
7009 bytes.
7010
7011   Thus, an encoding can be viewed as a way of encoding characters from a
7012 specified group of character sets using a stream of bytes, each of which
7013 contains a fixed number of bits (but not necessarily 8, as in the common
7014 usage of ``byte'').
7015
7016   Here are descriptions of a couple of common
7017 encodings:
7018
7019 @menu
7020 * Japanese EUC (Extended Unix Code)::
7021 * JIS7::
7022 @end menu
7023
7024 @node Japanese EUC (Extended Unix Code)
7025 @subsection Japanese EUC (Extended Unix Code)
7026
7027 This encompasses the character sets Printing-ASCII, Japanese-JISX0201,
7028 and Japanese-JISX0208-Kana (half-width katakana, the right half of
7029 JISX0201).  It uses 8-bit bytes.
7030
7031 Note that Printing-ASCII and Japanese-JISX0201-Kana are 94-character
7032 charsets, while Japanese-JISX0208 is a 94x94-character charset.
7033
7034 The encoding is as follows:
7035
7036 @example
7037 Character set            Representation (PC=position-code)
7038 -------------            --------------
7039 Printing-ASCII           PC1
7040 Japanese-JISX0201-Kana   0x8E       | PC1 + 0x80
7041 Japanese-JISX0208        PC1 + 0x80 | PC2 + 0x80
7042 Japanese-JISX0212        PC1 + 0x80 | PC2 + 0x80
7043 @end example
7044
7045
7046 @node JIS7
7047 @subsection JIS7
7048
7049 This encompasses the character sets Printing-ASCII,
7050 Japanese-JISX0201-Roman (the left half of JISX0201; this character set
7051 is very similar to Printing-ASCII and is a 94-character charset),
7052 Japanese-JISX0208, and Japanese-JISX0201-Kana.  It uses 7-bit bytes.
7053
7054 Unlike Japanese EUC, this is a @dfn{modal} encoding, which
7055 means that there are multiple states that the encoding can
7056 be in, which affect how the bytes are to be interpreted.
7057 Special sequences of bytes (called @dfn{escape sequences})
7058 are used to change states.
7059
7060   The encoding is as follows:
7061
7062 @example
7063 Character set              Representation (PC=position-code)
7064 -------------              --------------
7065 Printing-ASCII             PC1
7066 Japanese-JISX0201-Roman    PC1
7067 Japanese-JISX0201-Kana     PC1
7068 Japanese-JISX0208          PC1 PC2
7069
7070
7071 Escape sequence   ASCII equivalent   Meaning
7072 ---------------   ----------------   -------
7073 0x1B 0x28 0x4A    ESC ( J            invoke Japanese-JISX0201-Roman
7074 0x1B 0x28 0x49    ESC ( I            invoke Japanese-JISX0201-Kana
7075 0x1B 0x24 0x42    ESC $ B            invoke Japanese-JISX0208
7076 0x1B 0x28 0x42    ESC ( B            invoke Printing-ASCII
7077 @end example
7078
7079   Initially, Printing-ASCII is invoked.
7080
7081 @node Internal Mule Encodings
7082 @section Internal Mule Encodings
7083
7084 In XEmacs/Mule, each character set is assigned a unique number, called a
7085 @dfn{leading byte}.  This is used in the encodings of a character.
7086 Leading bytes are in the range 0x80 - 0xFF (except for ASCII, which has
7087 a leading byte of 0), although some leading bytes are reserved.
7088
7089 Charsets whose leading byte is in the range 0x80 - 0x9F are called
7090 @dfn{official} and are used for built-in charsets.  Other charsets are
7091 called @dfn{private} and have leading bytes in the range 0xA0 - 0xFF;
7092 these are user-defined charsets.
7093
7094   More specifically:
7095
7096 @example
7097 Character set           Leading byte
7098 -------------           ------------
7099 ASCII                   0
7100 Composite               0x80
7101 Dimension-1 Official    0x81 - 0x8D
7102                           (0x8E is free)
7103 Control-1               0x8F
7104 Dimension-2 Official    0x90 - 0x99
7105                           (0x9A - 0x9D are free;
7106                            0x9E and 0x9F are reserved)
7107 Dimension-1 Private     0xA0 - 0xEF
7108 Dimension-2 Private     0xF0 - 0xFF
7109 @end example
7110
7111 There are two internal encodings for characters in XEmacs/Mule.  One is
7112 called @dfn{string encoding} and is an 8-bit encoding that is used for
7113 representing characters in a buffer or string.  It uses 1 to 4 bytes per
7114 character.  The other is called @dfn{character encoding} and is a 19-bit
7115 encoding that is used for representing characters individually in a
7116 variable.
7117
7118 (In the following descriptions, we'll ignore composite characters for
7119 the moment.  We also give a general (structural) overview first,
7120 followed later by the exact details.)
7121
7122 @menu
7123 * Internal String Encoding::
7124 * Internal Character Encoding::
7125 @end menu
7126
7127 @node Internal String Encoding
7128 @subsection Internal String Encoding
7129
7130 ASCII characters are encoded using their position code directly.  Other
7131 characters are encoded using their leading byte followed by their
7132 position code(s) with the high bit set.  Characters in private character
7133 sets have their leading byte prefixed with a @dfn{leading byte prefix},
7134 which is either 0x9E or 0x9F. (No character sets are ever assigned these
7135 leading bytes.) Specifically:
7136
7137 @example
7138 Character set           Encoding (PC=position-code, LB=leading-byte)
7139 -------------           --------
7140 ASCII                   PC-1 |
7141 Control-1               LB   |  PC1 + 0xA0 |
7142 Dimension-1 official    LB   |  PC1 + 0x80 |
7143 Dimension-1 private     0x9E |  LB         | PC1 + 0x80 |
7144 Dimension-2 official    LB   |  PC1 + 0x80 | PC2 + 0x80 |
7145 Dimension-2 private     0x9F |  LB         | PC1 + 0x80 | PC2 + 0x80
7146 @end example
7147
7148   The basic characteristic of this encoding is that the first byte
7149 of all characters is in the range 0x00 - 0x9F, and the second and
7150 following bytes of all characters is in the range 0xA0 - 0xFF.
7151 This means that it is impossible to get out of sync, or more
7152 specifically:
7153
7154 @enumerate
7155 @item
7156 Given any byte position, the beginning of the character it is
7157 within can be determined in constant time.
7158 @item
7159 Given any byte position at the beginning of a character, the
7160 beginning of the next character can be determined in constant
7161 time.
7162 @item
7163 Given any byte position at the beginning of a character, the
7164 beginning of the previous character can be determined in constant
7165 time.
7166 @item
7167 Textual searches can simply treat encoded strings as if they
7168 were encoded in a one-byte-per-character fashion rather than
7169 the actual multi-byte encoding.
7170 @end enumerate
7171
7172   None of the standard non-modal encodings meet all of these
7173 conditions.  For example, EUC satisfies only (2) and (3), while
7174 Shift-JIS and Big5 (not yet described) satisfy only (2). (All
7175 non-modal encodings must satisfy (2), in order to be unambiguous.)
7176
7177 @node Internal Character Encoding
7178 @subsection Internal Character Encoding
7179
7180   One 19-bit word represents a single character.  The word is
7181 separated into three fields:
7182
7183 @example
7184 Bit number:     18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
7185                 <------------> <------------------> <------------------>
7186 Field:                1                  2                    3
7187 @end example
7188
7189   Note that fields 2 and 3 hold 7 bits each, while field 1 holds 5 bits.
7190
7191 @example
7192 Character set           Field 1         Field 2         Field 3
7193 -------------           -------         -------         -------
7194 ASCII                      0               0              PC1
7195    range:                                                   (00 - 7F)
7196 Control-1                  0               1              PC1
7197    range:                                                   (00 - 1F)
7198 Dimension-1 official       0            LB - 0x80         PC1
7199    range:                                    (01 - 0D)      (20 - 7F)
7200 Dimension-1 private        0            LB - 0x80         PC1
7201    range:                                    (20 - 6F)      (20 - 7F)
7202 Dimension-2 official    LB - 0x8F         PC1             PC2
7203    range:                    (01 - 0A)       (20 - 7F)      (20 - 7F)
7204 Dimension-2 private     LB - 0xE1         PC1             PC2
7205    range:                    (0F - 1E)       (20 - 7F)      (20 - 7F)
7206 Composite                 0x1F             ?               ?
7207 @end example
7208
7209   Note that character codes 0 - 255 are the same as the ``binary encoding''
7210 described above.
7211
7212 @node CCL
7213 @section CCL
7214
7215 @example
7216 CCL PROGRAM SYNTAX:
7217      CCL_PROGRAM := (CCL_MAIN_BLOCK
7218                      [ CCL_EOF_BLOCK ])
7219
7220      CCL_MAIN_BLOCK := CCL_BLOCK
7221      CCL_EOF_BLOCK := CCL_BLOCK
7222
7223      CCL_BLOCK := STATEMENT | (STATEMENT [STATEMENT ...])
7224      STATEMENT :=
7225              SET | IF | BRANCH | LOOP | REPEAT | BREAK
7226              | READ | WRITE
7227
7228      SET := (REG = EXPRESSION) | (REG SELF_OP EXPRESSION)
7229             | INT-OR-CHAR
7230
7231      EXPRESSION := ARG | (EXPRESSION OP ARG)
7232
7233      IF := (if EXPRESSION CCL_BLOCK CCL_BLOCK)
7234      BRANCH := (branch EXPRESSION CCL_BLOCK [CCL_BLOCK ...])
7235      LOOP := (loop STATEMENT [STATEMENT ...])
7236      BREAK := (break)
7237      REPEAT := (repeat)
7238              | (write-repeat [REG | INT-OR-CHAR | string])
7239              | (write-read-repeat REG [INT-OR-CHAR | string | ARRAY]?)
7240      READ := (read REG) | (read REG REG)
7241              | (read-if REG ARITH_OP ARG CCL_BLOCK CCL_BLOCK)
7242              | (read-branch REG CCL_BLOCK [CCL_BLOCK ...])
7243      WRITE := (write REG) | (write REG REG)
7244              | (write INT-OR-CHAR) | (write STRING) | STRING
7245              | (write REG ARRAY)
7246      END := (end)
7247
7248      REG := r0 | r1 | r2 | r3 | r4 | r5 | r6 | r7
7249      ARG := REG | INT-OR-CHAR
7250      OP :=   + | - | * | / | % | & | '|' | ^ | << | >> | <8 | >8 | //
7251              | < | > | == | <= | >= | !=
7252      SELF_OP :=
7253              += | -= | *= | /= | %= | &= | '|=' | ^= | <<= | >>=
7254      ARRAY := '[' INT-OR-CHAR ... ']'
7255      INT-OR-CHAR := INT | CHAR
7256
7257 MACHINE CODE:
7258
7259 The machine code consists of a vector of 32-bit words.
7260 The first such word specifies the start of the EOF section of the code;
7261 this is the code executed to handle any stuff that needs to be done
7262 (e.g. designating back to ASCII and left-to-right mode) after all
7263 other encoded/decoded data has been written out.  This is not used for
7264 charset CCL programs.
7265
7266 REGISTER: 0..7  -- refered by RRR or rrr
7267
7268 OPERATOR BIT FIELD (27-bit): XXXXXXXXXXXXXXX RRR TTTTT
7269         TTTTT (5-bit): operator type
7270         RRR (3-bit): register number
7271         XXXXXXXXXXXXXXXX (15-bit):
7272                 CCCCCCCCCCCCCCC: constant or address
7273                 000000000000rrr: register number
7274
7275 AAAA:   00000 +
7276         00001 -
7277         00010 *
7278         00011 /
7279         00100 %
7280         00101 &
7281         00110 |
7282         00111 ~
7283
7284         01000 <<
7285         01001 >>
7286         01010 <8
7287         01011 >8
7288         01100 //
7289         01101 not used
7290         01110 not used
7291         01111 not used
7292
7293         10000 <
7294         10001 >
7295         10010 ==
7296         10011 <=
7297         10100 >=
7298         10101 !=
7299
7300 OPERATORS:      TTTTT RRR XX..
7301
7302 SetCS:          00000 RRR C...C      RRR = C...C
7303 SetCL:          00001 RRR .....      RRR = c...c
7304                 c.............c
7305 SetR:           00010 RRR ..rrr      RRR = rrr
7306 SetA:           00011 RRR ..rrr      RRR = array[rrr]
7307                 C.............C      size of array = C...C
7308                 c.............c      contents = c...c
7309
7310 Jump:           00100 000 c...c      jump to c...c
7311 JumpCond:       00101 RRR c...c      if (!RRR) jump to c...c
7312 WriteJump:      00110 RRR c...c      Write1 RRR, jump to c...c
7313 WriteReadJump:  00111 RRR c...c      Write1, Read1 RRR, jump to c...c
7314 WriteCJump:     01000 000 c...c      Write1 C...C, jump to c...c
7315                 C...C
7316 WriteCReadJump: 01001 RRR c...c      Write1 C...C, Read1 RRR,
7317                 C.............C      and jump to c...c
7318 WriteSJump:     01010 000 c...c      WriteS, jump to c...c
7319                 C.............C
7320                 S.............S
7321                 ...
7322 WriteSReadJump: 01011 RRR c...c      WriteS, Read1 RRR, jump to c...c
7323                 C.............C
7324                 S.............S
7325                 ...
7326 WriteAReadJump: 01100 RRR c...c      WriteA, Read1 RRR, jump to c...c
7327                 C.............C      size of array = C...C
7328                 c.............c      contents = c...c
7329                 ...
7330 Branch:         01101 RRR C...C      if (RRR >= 0 && RRR < C..)
7331                 c.............c      branch to (RRR+1)th address
7332 Read1:          01110 RRR ...        read 1-byte to RRR
7333 Read2:          01111 RRR ..rrr      read 2-byte to RRR and rrr
7334 ReadBranch:     10000 RRR C...C      Read1 and Branch
7335                 c.............c
7336                 ...
7337 Write1:         10001 RRR .....      write 1-byte RRR
7338 Write2:         10010 RRR ..rrr      write 2-byte RRR and rrr
7339 WriteC:         10011 000 .....      write 1-char C...CC
7340                 C.............C
7341 WriteS:         10100 000 .....      write C..-byte of string
7342                 C.............C
7343                 S.............S
7344                 ...
7345 WriteA:         10101 RRR .....      write array[RRR]
7346                 C.............C      size of array = C...C
7347                 c.............c      contents = c...c
7348                 ...
7349 End:            10110 000 .....      terminate the execution
7350
7351 SetSelfCS:      10111 RRR C...C      RRR AAAAA= C...C
7352                 ..........AAAAA
7353 SetSelfCL:      11000 RRR .....      RRR AAAAA= c...c
7354                 c.............c
7355                 ..........AAAAA
7356 SetSelfR:       11001 RRR ..Rrr      RRR AAAAA= rrr
7357                 ..........AAAAA
7358 SetExprCL:      11010 RRR ..Rrr      RRR = rrr AAAAA c...c
7359                 c.............c
7360                 ..........AAAAA
7361 SetExprR:       11011 RRR ..rrr      RRR = rrr AAAAA Rrr
7362                 ............Rrr
7363                 ..........AAAAA
7364 JumpCondC:      11100 RRR c...c      if !(RRR AAAAA C..) jump to c...c
7365                 C.............C
7366                 ..........AAAAA
7367 JumpCondR:      11101 RRR c...c      if !(RRR AAAAA rrr) jump to c...c
7368                 ............rrr
7369                 ..........AAAAA
7370 ReadJumpCondC:  11110 RRR c...c      Read1 and JumpCondC
7371                 C.............C
7372                 ..........AAAAA
7373 ReadJumpCondR:  11111 RRR c...c      Read1 and JumpCondR
7374                 ............rrr
7375                 ..........AAAAA
7376 @end example
7377
7378 @node The Lisp Reader and Compiler, Lstreams, MULE Character Sets and Encodings, Top
7379 @chapter The Lisp Reader and Compiler
7380
7381 Not yet documented.
7382
7383 @node Lstreams, Consoles; Devices; Frames; Windows, The Lisp Reader and Compiler, Top
7384 @chapter Lstreams
7385
7386   An @dfn{lstream} is an internal Lisp object that provides a generic
7387 buffering stream implementation.  Conceptually, you send data to the
7388 stream or read data from the stream, not caring what's on the other end
7389 of the stream.  The other end could be another stream, a file
7390 descriptor, a stdio stream, a fixed block of memory, a reallocating
7391 block of memory, etc.  The main purpose of the stream is to provide a
7392 standard interface and to do buffering.  Macros are defined to read or
7393 write characters, so the calling functions do not have to worry about
7394 blocking data together in order to achieve efficiency.
7395
7396 @menu
7397 * Creating an Lstream::         Creating an lstream object.
7398 * Lstream Types::               Different sorts of things that are streamed.
7399 * Lstream Functions::           Functions for working with lstreams.
7400 * Lstream Methods::             Creating new lstream types.
7401 @end menu
7402
7403 @node Creating an Lstream
7404 @section Creating an Lstream
7405
7406 Lstreams come in different types, depending on what is being interfaced
7407 to.  Although the primitive for creating new lstreams is
7408 @code{Lstream_new()}, generally you do not call this directly.  Instead,
7409 you call some type-specific creation function, which creates the lstream
7410 and initializes it as appropriate for the particular type.
7411
7412 All lstream creation functions take a @var{mode} argument, specifying
7413 what mode the lstream should be opened as.  This controls whether the
7414 lstream is for input and output, and optionally whether data should be
7415 blocked up in units of MULE characters.  Note that some types of
7416 lstreams can only be opened for input; others only for output; and
7417 others can be opened either way.  #### Richard Mlynarik thinks that
7418 there should be a strict separation between input and output streams,
7419 and he's probably right.
7420
7421   @var{mode} is a string, one of
7422
7423 @table @code
7424 @item "r"
7425   Open for reading.
7426 @item "w"
7427   Open for writing.
7428 @item "rc"
7429   Open for reading, but ``read'' never returns partial MULE characters.
7430 @item "wc"
7431   Open for writing, but never writes partial MULE characters.
7432 @end table
7433
7434 @node Lstream Types
7435 @section Lstream Types
7436
7437 @table @asis
7438 @item stdio
7439
7440 @item filedesc
7441
7442 @item lisp-string
7443
7444 @item fixed-buffer
7445
7446 @item resizing-buffer
7447
7448 @item dynarr
7449
7450 @item lisp-buffer
7451
7452 @item print
7453
7454 @item decoding
7455
7456 @item encoding
7457 @end table
7458
7459 @node Lstream Functions
7460 @section Lstream Functions
7461
7462 @deftypefun {Lstream *} Lstream_new (Lstream_implementation *@var{imp}, CONST char *@var{mode})
7463 Allocate and return a new Lstream.  This function is not really meant to
7464 be called directly; rather, each stream type should provide its own
7465 stream creation function, which creates the stream and does any other
7466 necessary creation stuff (e.g. opening a file).
7467 @end deftypefun
7468
7469 @deftypefun void Lstream_set_buffering (Lstream *@var{lstr}, Lstream_buffering @var{buffering}, int @var{buffering_size})
7470 Change the buffering of a stream.  See @file{lstream.h}.  By default the
7471 buffering is @code{STREAM_BLOCK_BUFFERED}.
7472 @end deftypefun
7473
7474 @deftypefun int Lstream_flush (Lstream *@var{lstr})
7475 Flush out any pending unwritten data in the stream.  Clear any buffered
7476 input data.  Returns 0 on success, -1 on error.
7477 @end deftypefun
7478
7479 @deftypefn Macro int Lstream_putc (Lstream *@var{stream}, int @var{c})
7480 Write out one byte to the stream.  This is a macro and so it is very
7481 efficient.  The @var{c} argument is only evaluated once but the @var{stream}
7482 argument is evaluated more than once.  Returns 0 on success, -1 on
7483 error.
7484 @end deftypefn
7485
7486 @deftypefn Macro int Lstream_getc (Lstream *@var{stream})
7487 Read one byte from the stream.  This is a macro and so it is very
7488 efficient.  The @var{stream} argument is evaluated more than once.  Return
7489 value is -1 for EOF or error.
7490 @end deftypefn
7491
7492 @deftypefn Macro void Lstream_ungetc (Lstream *@var{stream}, int @var{c})
7493 Push one byte back onto the input queue.  This will be the next byte
7494 read from the stream.  Any number of bytes can be pushed back and will
7495 be read in the reverse order they were pushed back -- most recent
7496 first. (This is necessary for consistency -- if there are a number of
7497 bytes that have been unread and I read and unread a byte, it needs to be
7498 the first to be read again.) This is a macro and so it is very
7499 efficient.  The @var{c} argument is only evaluated once but the @var{stream}
7500 argument is evaluated more than once.
7501 @end deftypefn
7502
7503 @deftypefun int Lstream_fputc (Lstream *@var{stream}, int @var{c})
7504 @deftypefunx int Lstream_fgetc (Lstream *@var{stream})
7505 @deftypefunx void Lstream_fungetc (Lstream *@var{stream}, int @var{c})
7506 Function equivalents of the above macros.
7507 @end deftypefun
7508
7509 @deftypefun int Lstream_read (Lstream *@var{stream}, void *@var{data}, int @var{size})
7510 Read @var{size} bytes of @var{data} from the stream.  Return the number
7511 of bytes read.  0 means EOF. -1 means an error occurred and no bytes
7512 were read.
7513 @end deftypefun
7514
7515 @deftypefun int Lstream_write (Lstream *@var{stream}, void *@var{data}, int @var{size})
7516 Write @var{size} bytes of @var{data} to the stream.  Return the number
7517 of bytes written.  -1 means an error occurred and no bytes were written.
7518 @end deftypefun
7519
7520 @deftypefun void Lstream_unread (Lstream *@var{stream}, void *@var{data}, int @var{size})
7521 Push back @var{size} bytes of @var{data} onto the input queue.  The next
7522 call to @code{Lstream_read()} with the same size will read the same
7523 bytes back.  Note that this will be the case even if there is other
7524 pending unread data.
7525 @end deftypefun
7526
7527 @deftypefun int Lstream_close (Lstream *@var{stream})
7528 Close the stream.  All data will be flushed out.
7529 @end deftypefun
7530
7531 @deftypefun void Lstream_reopen (Lstream *@var{stream})
7532 Reopen a closed stream.  This enables I/O on it again.  This is not
7533 meant to be called except from a wrapper routine that reinitializes
7534 variables and such -- the close routine may well have freed some
7535 necessary storage structures, for example.
7536 @end deftypefun
7537
7538 @deftypefun void Lstream_rewind (Lstream *@var{stream})
7539 Rewind the stream to the beginning.
7540 @end deftypefun
7541
7542 @node Lstream Methods
7543 @section Lstream Methods
7544
7545 @deftypefn {Lstream Method} int reader (Lstream *@var{stream}, unsigned char *@var{data}, int @var{size})
7546 Read some data from the stream's end and store it into @var{data}, which
7547 can hold @var{size} bytes.  Return the number of bytes read.  A return
7548 value of 0 means no bytes can be read at this time.  This may be because
7549 of an EOF, or because there is a granularity greater than one byte that
7550 the stream imposes on the returned data, and @var{size} is less than
7551 this granularity. (This will happen frequently for streams that need to
7552 return whole characters, because @code{Lstream_read()} calls the reader
7553 function repeatedly until it has the number of bytes it wants or until 0
7554 is returned.)  The lstream functions do not treat a 0 return as EOF or
7555 do anything special; however, the calling function will interpret any 0
7556 it gets back as EOF.  This will normally not happen unless the caller
7557 calls @code{Lstream_read()} with a very small size.
7558
7559 This function can be @code{NULL} if the stream is output-only.
7560 @end deftypefn
7561
7562 @deftypefn {Lstream Method} int writer (Lstream *@var{stream}, CONST unsigned char *@var{data}, int @var{size})
7563 Send some data to the stream's end.  Data to be sent is in @var{data}
7564 and is @var{size} bytes.  Return the number of bytes sent.  This
7565 function can send and return fewer bytes than is passed in; in that
7566 case, the function will just be called again until there is no data left
7567 or 0 is returned.  A return value of 0 means that no more data can be
7568 currently stored, but there is no error; the data will be squirreled
7569 away until the writer can accept data. (This is useful, e.g., if you're
7570 dealing with a non-blocking file descriptor and are getting
7571 @code{EWOULDBLOCK} errors.)  This function can be @code{NULL} if the
7572 stream is input-only.
7573 @end deftypefn
7574
7575 @deftypefn {Lstream Method} int rewinder (Lstream *@var{stream})
7576 Rewind the stream.  If this is @code{NULL}, the stream is not seekable.
7577 @end deftypefn
7578
7579 @deftypefn {Lstream Method} int seekable_p (Lstream *@var{stream})
7580 Indicate whether this stream is seekable -- i.e. it can be rewound.
7581 This method is ignored if the stream does not have a rewind method.  If
7582 this method is not present, the result is determined by whether a rewind
7583 method is present.
7584 @end deftypefn
7585
7586 @deftypefn {Lstream Method} int flusher (Lstream *@var{stream})
7587 Perform any additional operations necessary to flush the data in this
7588 stream.
7589 @end deftypefn
7590
7591 @deftypefn {Lstream Method} int pseudo_closer (Lstream *@var{stream})
7592 @end deftypefn
7593
7594 @deftypefn {Lstream Method} int closer (Lstream *@var{stream})
7595 Perform any additional operations necessary to close this stream down.
7596 May be @code{NULL}.  This function is called when @code{Lstream_close()}
7597 is called or when the stream is garbage-collected.  When this function
7598 is called, all pending data in the stream will already have been written
7599 out.
7600 @end deftypefn
7601
7602 @deftypefn {Lstream Method} Lisp_Object marker (Lisp_Object @var{lstream}, void (*@var{markfun}) (Lisp_Object))
7603 Mark this object for garbage collection.  Same semantics as a standard
7604 @code{Lisp_Object} marker.  This function can be @code{NULL}.
7605 @end deftypefn
7606
7607 @node Consoles; Devices; Frames; Windows, The Redisplay Mechanism, Lstreams, Top
7608 @chapter Consoles; Devices; Frames; Windows
7609
7610 @menu
7611 * Introduction to Consoles; Devices; Frames; Windows::
7612 * Point::
7613 * Window Hierarchy::
7614 * The Window Object::
7615 @end menu
7616
7617 @node Introduction to Consoles; Devices; Frames; Windows
7618 @section Introduction to Consoles; Devices; Frames; Windows
7619
7620 A window-system window that you see on the screen is called a
7621 @dfn{frame} in Emacs terminology.  Each frame is subdivided into one or
7622 more non-overlapping panes, called (confusingly) @dfn{windows}.  Each
7623 window displays the text of a buffer in it. (See above on Buffers.) Note
7624 that buffers and windows are independent entities: Two or more windows
7625 can be displaying the same buffer (potentially in different locations),
7626 and a buffer can be displayed in no windows.
7627
7628   A single display screen that contains one or more frames is called
7629 a @dfn{display}.  Under most circumstances, there is only one display.
7630 However, more than one display can exist, for example if you have
7631 a @dfn{multi-headed} console, i.e. one with a single keyboard but
7632 multiple displays. (Typically in such a situation, the various
7633 displays act like one large display, in that the mouse is only
7634 in one of them at a time, and moving the mouse off of one moves
7635 it into another.) In some cases, the different displays will
7636 have different characteristics, e.g. one color and one mono.
7637
7638   XEmacs can display frames on multiple displays.  It can even deal
7639 simultaneously with frames on multiple keyboards (called @dfn{consoles} in
7640 XEmacs terminology).  Here is one case where this might be useful: You
7641 are using XEmacs on your workstation at work, and leave it running.
7642 Then you go home and dial in on a TTY line, and you can use the
7643 already-running XEmacs process to display another frame on your local
7644 TTY.
7645
7646   Thus, there is a hierarchy console -> display -> frame -> window.
7647 There is a separate Lisp object type for each of these four concepts.
7648 Furthermore, there is logically a @dfn{selected console},
7649 @dfn{selected display}, @dfn{selected frame}, and @dfn{selected window}.
7650 Each of these objects is distinguished in various ways, such as being the
7651 default object for various functions that act on objects of that type.
7652 Note that every containing object rememembers the ``selected'' object
7653 among the objects that it contains: e.g. not only is there a selected
7654 window, but every frame remembers the last window in it that was
7655 selected, and changing the selected frame causes the remembered window
7656 within it to become the selected window.  Similar relationships apply
7657 for consoles to devices and devices to frames.
7658
7659 @node Point
7660 @section Point
7661
7662   Recall that every buffer has a current insertion position, called
7663 @dfn{point}.  Now, two or more windows may be displaying the same buffer,
7664 and the text cursor in the two windows (i.e. @code{point}) can be in
7665 two different places.  You may ask, how can that be, since each
7666 buffer has only one value of @code{point}?  The answer is that each window
7667 also has a value of @code{point} that is squirreled away in it.  There
7668 is only one selected window, and the value of ``point'' in that buffer
7669 corresponds to that window.  When the selected window is changed
7670 from one window to another displaying the same buffer, the old
7671 value of @code{point} is stored into the old window's ``point'' and the
7672 value of @code{point} from the new window is retrieved and made the
7673 value of @code{point} in the buffer.  This means that @code{window-point}
7674 for the selected window is potentially inaccurate, and if you
7675 want to retrieve the correct value of @code{point} for a window,
7676 you must special-case on the selected window and retrieve the
7677 buffer's point instead.  This is related to why @code{save-window-excursion}
7678 does not save the selected window's value of @code{point}.
7679
7680 @node Window Hierarchy
7681 @section Window Hierarchy
7682 @cindex window hierarchy
7683 @cindex hierarchy of windows
7684
7685   If a frame contains multiple windows (panes), they are always created
7686 by splitting an existing window along the horizontal or vertical axis.
7687 Terminology is a bit confusing here: to @dfn{split a window
7688 horizontally} means to create two side-by-side windows, i.e. to make a
7689 @emph{vertical} cut in a window.  Likewise, to @dfn{split a window
7690 vertically} means to create two windows, one above the other, by making
7691 a @emph{horizontal} cut.
7692
7693   If you split a window and then split again along the same axis, you
7694 will end up with a number of panes all arranged along the same axis.
7695 The precise way in which the splits were made should not be important,
7696 and this is reflected internally.  Internally, all windows are arranged
7697 in a tree, consisting of two types of windows, @dfn{combination} windows
7698 (which have children, and are covered completely by those children) and
7699 @dfn{leaf} windows, which have no children and are visible.  Every
7700 combination window has two or more children, all arranged along the same
7701 axis.  There are (logically) two subtypes of windows, depending on
7702 whether their children are horizontally or vertically arrayed.  There is
7703 always one root window, which is either a leaf window (if the frame
7704 contains only one window) or a combination window (if the frame contains
7705 more than one window).  In the latter case, the root window will have
7706 two or more children, either horizontally or vertically arrayed, and
7707 each of those children will be either a leaf window or another
7708 combination window.
7709
7710   Here are some rules:
7711
7712 @enumerate
7713 @item
7714 Horizontal combination windows can never have children that are
7715 horizontal combination windows; same for vertical.
7716
7717 @item
7718 Only leaf windows can be split (obviously) and this splitting does one
7719 of two things: (a) turns the leaf window into a combination window and
7720 creates two new leaf children, or (b) turns the leaf window into one of
7721 the two new leaves and creates the other leaf.  Rule (1) dictates which
7722 of these two outcomes happens.
7723
7724 @item
7725 Every combination window must have at least two children.
7726
7727 @item
7728 Leaf windows can never become combination windows.  They can be deleted,
7729 however.  If this results in a violation of (3), the parent combination
7730 window also gets deleted.
7731
7732 @item
7733 All functions that accept windows must be prepared to accept combination
7734 windows, and do something sane (e.g. signal an error if so).
7735 Combination windows @emph{do} escape to the Lisp level.
7736
7737 @item
7738 All windows have three fields governing their contents:
7739 these are @dfn{hchild} (a list of horizontally-arrayed children),
7740 @dfn{vchild} (a list of vertically-arrayed children), and @dfn{buffer}
7741 (the buffer contained in a leaf window).  Exactly one of
7742 these will be non-nil.  Remember that @dfn{horizontally-arrayed}
7743 means ``side-by-side'' and @dfn{vertically-arrayed} means
7744 @dfn{one above the other}.
7745
7746 @item
7747 Leaf windows also have markers in their @code{start} (the
7748 first buffer position displayed in the window) and @code{pointm}
7749 (the window's stashed value of @code{point} -- see above) fields,
7750 while combination windows have nil in these fields.
7751
7752 @item
7753 The list of children for a window is threaded through the
7754 @code{next} and @code{prev} fields of each child window.
7755
7756 @item
7757 @strong{Deleted windows can be undeleted}.  This happens as a result of
7758 restoring a window configuration, and is unlike frames, displays, and
7759 consoles, which, once deleted, can never be restored.  Deleting a window
7760 does nothing except set a special @code{dead} bit to 1 and clear out the
7761 @code{next}, @code{prev}, @code{hchild}, and @code{vchild} fields, for
7762 GC purposes.
7763
7764 @item
7765 Most frames actually have two top-level windows -- one for the
7766 minibuffer and one (the @dfn{root}) for everything else.  The modeline
7767 (if present) separates these two.  The @code{next} field of the root
7768 points to the minibuffer, and the @code{prev} field of the minibuffer
7769 points to the root.  The other @code{next} and @code{prev} fields are
7770 @code{nil}, and the frame points to both of these windows.
7771 Minibuffer-less frames have no minibuffer window, and the @code{next}
7772 and @code{prev} of the root window are @code{nil}.  Minibuffer-only
7773 frames have no root window, and the @code{next} of the minibuffer window
7774 is @code{nil} but the @code{prev} points to itself. (#### This is an
7775 artifact that should be fixed.)
7776 @end enumerate
7777
7778 @node The Window Object
7779 @section The Window Object
7780
7781   Windows have the following accessible fields:
7782
7783 @table @code
7784 @item frame
7785 The frame that this window is on.
7786
7787 @item mini_p
7788 Non-@code{nil} if this window is a minibuffer window.
7789
7790 @item buffer
7791 The buffer that the window is displaying.  This may change often during
7792 the life of the window.
7793
7794 @item dedicated
7795 Non-@code{nil} if this window is dedicated to its buffer.
7796
7797 @item pointm
7798 @cindex window point internals
7799 This is the value of point in the current buffer when this window is
7800 selected; when it is not selected, it retains its previous value.
7801
7802 @item start
7803 The position in the buffer that is the first character to be displayed
7804 in the window.
7805
7806 @item force_start
7807 If this flag is non-@code{nil}, it says that the window has been
7808 scrolled explicitly by the Lisp program.  This affects what the next
7809 redisplay does if point is off the screen: instead of scrolling the
7810 window to show the text around point, it moves point to a location that
7811 is on the screen.
7812
7813 @item last_modified
7814 The @code{modified} field of the window's buffer, as of the last time
7815 a redisplay completed in this window.
7816
7817 @item last_point
7818 The buffer's value of point, as of the last time
7819 a redisplay completed in this window.
7820
7821 @item left
7822 This is the left-hand edge of the window, measured in columns.  (The
7823 leftmost column on the screen is @w{column 0}.)
7824
7825 @item top
7826 This is the top edge of the window, measured in lines.  (The top line on
7827 the screen is @w{line 0}.)
7828
7829 @item height
7830 The height of the window, measured in lines.
7831
7832 @item width
7833 The width of the window, measured in columns.
7834
7835 @item next
7836 This is the window that is the next in the chain of siblings.  It is
7837 @code{nil} in a window that is the rightmost or bottommost of a group of
7838 siblings.
7839
7840 @item prev
7841 This is the window that is the previous in the chain of siblings.  It is
7842 @code{nil} in a window that is the leftmost or topmost of a group of
7843 siblings.
7844
7845 @item parent
7846 Internally, XEmacs arranges windows in a tree; each group of siblings has
7847 a parent window whose area includes all the siblings.  This field points
7848 to a window's parent.
7849
7850 Parent windows do not display buffers, and play little role in display
7851 except to shape their child windows.  Emacs Lisp programs usually have
7852 no access to the parent windows; they operate on the windows at the
7853 leaves of the tree, which actually display buffers.
7854
7855 @item hscroll
7856 This is the number of columns that the display in the window is scrolled
7857 horizontally to the left.  Normally, this is 0.
7858
7859 @item use_time
7860 This is the last time that the window was selected.  The function
7861 @code{get-lru-window} uses this field.
7862
7863 @item display_table
7864 The window's display table, or @code{nil} if none is specified for it.
7865
7866 @item update_mode_line
7867 Non-@code{nil} means this window's mode line needs to be updated.
7868
7869 @item base_line_number
7870 The line number of a certain position in the buffer, or @code{nil}.
7871 This is used for displaying the line number of point in the mode line.
7872
7873 @item base_line_pos
7874 The position in the buffer for which the line number is known, or
7875 @code{nil} meaning none is known.
7876
7877 @item region_showing
7878 If the region (or part of it) is highlighted in this window, this field
7879 holds the mark position that made one end of that region.  Otherwise,
7880 this field is @code{nil}.
7881 @end table
7882
7883 @node The Redisplay Mechanism, Extents, Consoles; Devices; Frames; Windows, Top
7884 @chapter The Redisplay Mechanism
7885
7886   The redisplay mechanism is one of the most complicated sections of
7887 XEmacs, especially from a conceptual standpoint.  This is doubly so
7888 because, unlike for the basic aspects of the Lisp interpreter, the
7889 computer science theories of how to efficiently handle redisplay are not
7890 well-developed.
7891
7892   When working with the redisplay mechanism, remember the Golden Rules
7893 of Redisplay:
7894
7895 @enumerate
7896 @item
7897 It Is Better To Be Correct Than Fast.
7898 @item
7899 Thou Shalt Not Run Elisp From Within Redisplay.
7900 @item
7901 It Is Better To Be Fast Than Not To Be.
7902 @end enumerate
7903
7904 @menu
7905 * Critical Redisplay Sections::
7906 * Line Start Cache::
7907 * Redisplay Piece by Piece::
7908 @end menu
7909
7910 @node Critical Redisplay Sections
7911 @section Critical Redisplay Sections
7912 @cindex critical redisplay sections
7913
7914 Within this section, we are defenseless and assume that the
7915 following cannot happen:
7916
7917 @enumerate
7918 @item
7919 garbage collection
7920 @item
7921 Lisp code evaluation
7922 @item
7923 frame size changes
7924 @end enumerate
7925
7926 We ensure (3) by calling @code{hold_frame_size_changes()}, which
7927 will cause any pending frame size changes to get put on hold
7928 till after the end of the critical section.  (1) follows
7929 automatically if (2) is met.  #### Unfortunately, there are
7930 some places where Lisp code can be called within this section.
7931 We need to remove them.
7932
7933 If @code{Fsignal()} is called during this critical section, we
7934 will @code{abort()}.
7935
7936 If garbage collection is called during this critical section,
7937 we simply return. #### We should abort instead.
7938
7939 #### If a frame-size change does occur we should probably
7940 actually be preempting redisplay.
7941
7942 @node Line Start Cache
7943 @section Line Start Cache
7944 @cindex line start cache
7945
7946   The traditional scrolling code in Emacs breaks in a variable height
7947 world.  It depends on the key assumption that the number of lines that
7948 can be displayed at any given time is fixed.  This led to a complete
7949 separation of the scrolling code from the redisplay code.  In order to
7950 fully support variable height lines, the scrolling code must actually be
7951 tightly integrated with redisplay.  Only redisplay can determine how
7952 many lines will be displayed on a screen for any given starting point.
7953
7954   What is ideally wanted is a complete list of the starting buffer
7955 position for every possible display line of a buffer along with the
7956 height of that display line.  Maintaining such a full list would be very
7957 expensive.  We settle for having it include information for all areas
7958 which we happen to generate anyhow (i.e. the region currently being
7959 displayed) and for those areas we need to work with.
7960
7961   In order to ensure that the cache accurately represents what redisplay
7962 would actually show, it is necessary to invalidate it in many
7963 situations.  If the buffer changes, the starting positions may no longer
7964 be correct.  If a face or an extent has changed then the line heights
7965 may have altered.  These events happen frequently enough that the cache
7966 can end up being constantly disabled.  With this potentially constant
7967 invalidation when is the cache ever useful?
7968
7969   Even if the cache is invalidated before every single usage, it is
7970 necessary.  Scrolling often requires knowledge about display lines which
7971 are actually above or below the visible region.  The cache provides a
7972 convenient light-weight method of storing this information for multiple
7973 display regions.  This knowledge is necessary for the scrolling code to
7974 always obey the First Golden Rule of Redisplay.
7975
7976   If the cache already contains all of the information that the scrolling
7977 routines happen to need so that it doesn't have to go generate it, then
7978 we are able to obey the Third Golden Rule of Redisplay.  The first thing
7979 we do to help out the cache is to always add the displayed region.  This
7980 region had to be generated anyway, so the cache ends up getting the
7981 information basically for free.  In those cases where a user is simply
7982 scrolling around viewing a buffer there is a high probability that this
7983 is sufficient to always provide the needed information.  The second
7984 thing we can do is be smart about invalidating the cache.
7985
7986   TODO -- Be smart about invalidating the cache.  Potential places:
7987
7988 @itemize @bullet
7989 @item
7990 Insertions at end-of-line which don't cause line-wraps do not alter the
7991 starting positions of any display lines.  These types of buffer
7992 modifications should not invalidate the cache.  This is actually a large
7993 optimization for redisplay speed as well.
7994 @item
7995 Buffer modifications frequently only affect the display of lines at and
7996 below where they occur.  In these situations we should only invalidate
7997 the part of the cache starting at where the modification occurs.
7998 @end itemize
7999
8000   In case you're wondering, the Second Golden Rule of Redisplay is not
8001 applicable.
8002
8003 @node Redisplay Piece by Piece
8004 @section Redisplay Piece by Piece
8005 @cindex Redisplay Piece by Piece
8006
8007 As you can begin to see redisplay is complex and also not well
8008 documented. Chuck no longer works on XEmacs so this section is my take
8009 on the workings of redisplay.
8010
8011 Redisplay happens in three phases:
8012
8013 @enumerate
8014 @item
8015 Determine desired display in area that needs redisplay.
8016 Implemented by @code{redisplay.c}
8017 @item
8018 Compare desired display with current display
8019 Implemented by @code{redisplay-output.c}
8020 @item
8021 Output changes Implemented by @code{redisplay-output.c},
8022 @code{redisplay-x.c}, @code{redisplay-msw.c} and @code{redisplay-tty.c}
8023 @end enumerate
8024
8025 Steps 1 and 2 are device-independant and relatively complex.  Step 3 is
8026 mostly device-dependent.
8027
8028 Determining the desired display
8029
8030 Display attributes are stored in @code{display_line} structures. Each
8031 @code{display_line} consists of a set of @code{display_block}'s and each
8032 @code{display_block} contains a number of @code{rune}'s. Generally
8033 dynarr's of @code{display_line}'s are held by each window representing
8034 the current display and the desired display.
8035
8036 The @code{display_line} structures are tighly tied to buffers which
8037 presents a problem for redisplay as this connection is bogus for the
8038 modeline. Hence the @code{display_line} generation routines are
8039 duplicated for generating the modeline. This means that the modeline
8040 display code has many bugs that the standard redisplay code does not.
8041
8042 The guts of @code{display_line} generation are in
8043 @code{create_text_block}, which creates a single display line for the
8044 desired locale. This incrementally parses the characters on the current
8045 line and generates redisplay structures for each. 
8046
8047 Gutter redisplay is different. Because the data to display is stored in
8048 a string we cannot use @code{create_text_block}. Instead we use
8049 @code{create_text_string_block} which performs the same function as
8050 @code{create_text_block} but for strings. Many of the complexities of
8051 @code{create_text_block} to do with cursor handling and selective
8052 display have been removed.
8053
8054 @node Extents, Faces, The Redisplay Mechanism, Top
8055 @chapter Extents
8056
8057 @menu
8058 * Introduction to Extents::     Extents are ranges over text, with properties.
8059 * Extent Ordering::             How extents are ordered internally.
8060 * Format of the Extent Info::   The extent information in a buffer or string.
8061 * Zero-Length Extents::         A weird special case.
8062 * Mathematics of Extent Ordering::      A rigorous foundation.
8063 * Extent Fragments::            Cached information useful for redisplay.
8064 @end menu
8065
8066 @node Introduction to Extents
8067 @section Introduction to Extents
8068
8069   Extents are regions over a buffer, with a start and an end position
8070 denoting the region of the buffer included in the extent.  In
8071 addition, either end can be closed or open, meaning that the endpoint
8072 is or is not logically included in the extent.  Insertion of a character
8073 at a closed endpoint causes the character to go inside the extent;
8074 insertion at an open endpoint causes the character to go outside.
8075
8076   Extent endpoints are stored using memory indices (see @file{insdel.c}),
8077 to minimize the amount of adjusting that needs to be done when
8078 characters are inserted or deleted.
8079
8080   (Formerly, extent endpoints at the gap could be either before or
8081 after the gap, depending on the open/closedness of the endpoint.
8082 The intent of this was to make it so that insertions would
8083 automatically go inside or out of extents as necessary with no
8084 further work needing to be done.  It didn't work out that way,
8085 however, and just ended up complexifying and buggifying all the
8086 rest of the code.)
8087
8088 @node Extent Ordering
8089 @section Extent Ordering
8090
8091   Extents are compared using memory indices.  There are two orderings
8092 for extents and both orders are kept current at all times.  The normal
8093 or @dfn{display} order is as follows:
8094
8095 @example
8096 Extent A is ``less than'' extent B,
8097 that is, earlier in the display order,
8098   if:    A-start < B-start,
8099   or if: A-start = B-start, and A-end > B-end
8100 @end example
8101
8102   So if two extents begin at the same position, the larger of them is the
8103 earlier one in the display order (@code{EXTENT_LESS} is true).
8104
8105   For the e-order, the same thing holds:
8106
8107 @example
8108 Extent A is ``less than'' extent B in e-order,
8109 that is, later in the buffer,
8110   if:    A-end < B-end,
8111   or if: A-end = B-end, and A-start > B-start
8112 @end example
8113
8114   So if two extents end at the same position, the smaller of them is the
8115 earlier one in the e-order (@code{EXTENT_E_LESS} is true).
8116
8117   The display order and the e-order are complementary orders: any
8118 theorem about the display order also applies to the e-order if you swap
8119 all occurrences of ``display order'' and ``e-order'', ``less than'' and
8120 ``greater than'', and ``extent start'' and ``extent end''.
8121
8122 @node Format of the Extent Info
8123 @section Format of the Extent Info
8124
8125   An extent-info structure consists of a list of the buffer or string's
8126 extents and a @dfn{stack of extents} that lists all of the extents over
8127 a particular position.  The stack-of-extents info is used for
8128 optimization purposes -- it basically caches some info that might
8129 be expensive to compute.  Certain otherwise hard computations are easy
8130 given the stack of extents over a particular position, and if the
8131 stack of extents over a nearby position is known (because it was
8132 calculated at some prior point in time), it's easy to move the stack
8133 of extents to the proper position.
8134
8135   Given that the stack of extents is an optimization, and given that
8136 it requires memory, a string's stack of extents is wiped out each
8137 time a garbage collection occurs.  Therefore, any time you retrieve
8138 the stack of extents, it might not be there.  If you need it to
8139 be there, use the @code{_force} version.
8140
8141   Similarly, a string may or may not have an extent_info structure.
8142 (Generally it won't if there haven't been any extents added to the
8143 string.) So use the @code{_force} version if you need the extent_info
8144 structure to be there.
8145
8146   A list of extents is maintained as a double gap array: one gap array
8147 is ordered by start index (the @dfn{display order}) and the other is
8148 ordered by end index (the @dfn{e-order}).  Note that positions in an
8149 extent list should logically be conceived of as referring @emph{to} a
8150 particular extent (as is the norm in programs) rather than sitting
8151 between two extents.  Note also that callers of these functions should
8152 not be aware of the fact that the extent list is implemented as an
8153 array, except for the fact that positions are integers (this should be
8154 generalized to handle integers and linked list equally well).
8155
8156 @node Zero-Length Extents
8157 @section Zero-Length Extents
8158
8159   Extents can be zero-length, and will end up that way if their endpoints
8160 are explicitly set that way or if their detachable property is nil
8161 and all the text in the extent is deleted. (The exception is open-open
8162 zero-length extents, which are barred from existing because there is
8163 no sensible way to define their properties.  Deletion of the text in
8164 an open-open extent causes it to be converted into a closed-open
8165 extent.)  Zero-length extents are primarily used to represent
8166 annotations, and behave as follows:
8167
8168 @enumerate
8169 @item
8170 Insertion at the position of a zero-length extent expands the extent
8171 if both endpoints are closed; goes after the extent if it is closed-open;
8172 and goes before the extent if it is open-closed.
8173
8174 @item
8175 Deletion of a character on a side of a zero-length extent whose
8176 corresponding endpoint is closed causes the extent to be detached if
8177 it is detachable; if the extent is not detachable or the corresponding
8178 endpoint is open, the extent remains in the buffer, moving as necessary.
8179 @end enumerate
8180
8181   Note that closed-open, non-detachable zero-length extents behave
8182 exactly like markers and that open-closed, non-detachable zero-length
8183 extents behave like the ``point-type'' marker in Mule.
8184
8185 @node Mathematics of Extent Ordering
8186 @section Mathematics of Extent Ordering
8187 @cindex extent mathematics
8188 @cindex mathematics of extents
8189 @cindex extent ordering
8190
8191 @cindex display order of extents
8192 @cindex extents, display order
8193   The extents in a buffer are ordered by ``display order'' because that
8194 is that order that the redisplay mechanism needs to process them in.
8195 The e-order is an auxiliary ordering used to facilitate operations
8196 over extents.  The operations that can be performed on the ordered
8197 list of extents in a buffer are
8198
8199 @enumerate
8200 @item
8201 Locate where an extent would go if inserted into the list.
8202 @item
8203 Insert an extent into the list.
8204 @item
8205 Remove an extent from the list.
8206 @item
8207 Map over all the extents that overlap a range.
8208 @end enumerate
8209
8210   (4) requires being able to determine the first and last extents
8211 that overlap a range.
8212
8213   NOTE: @dfn{overlap} is used as follows:
8214
8215 @itemize @bullet
8216 @item
8217 two ranges overlap if they have at least one point in common.
8218 Whether the endpoints are open or closed makes a difference here.
8219 @item
8220 a point overlaps a range if the point is contained within the
8221 range; this is equivalent to treating a point @math{P} as the range
8222 @math{[P, P]}.
8223 @item
8224 In the case of an @emph{extent} overlapping a point or range, the extent
8225 is normally treated as having closed endpoints.  This applies
8226 consistently in the discussion of stacks of extents and such below.
8227 Note that this definition of overlap is not necessarily consistent with
8228 the extents that @code{map-extents} maps over, since @code{map-extents}
8229 sometimes pays attention to whether the endpoints of an extents are open
8230 or closed.  But for our purposes, it greatly simplifies things to treat
8231 all extents as having closed endpoints.
8232 @end itemize
8233
8234 First, define @math{>}, @math{<}, @math{<=}, etc. as applied to extents
8235 to mean comparison according to the display order.  Comparison between
8236 an extent @math{E} and an index @math{I} means comparison between
8237 @math{E} and the range @math{[I, I]}.
8238
8239 Also define @math{e>}, @math{e<}, @math{e<=}, etc. to mean comparison
8240 according to the e-order.
8241
8242 For any range @math{R}, define @math{R(0)} to be the starting index of
8243 the range and @math{R(1)} to be the ending index of the range.
8244
8245 For any extent @math{E}, define @math{E(next)} to be the extent directly
8246 following @math{E}, and @math{E(prev)} to be the extent directly
8247 preceding @math{E}.  Assume @math{E(next)} and @math{E(prev)} can be
8248 determined from @math{E} in constant time.  (This is because we store
8249 the extent list as a doubly linked list.)
8250
8251 Similarly, define @math{E(e-next)} and @math{E(e-prev)} to be the
8252 extents directly following and preceding @math{E} in the e-order.
8253
8254 Now:
8255
8256 Let @math{R} be a range.
8257 Let @math{F} be the first extent overlapping @math{R}.
8258 Let @math{L} be the last extent overlapping @math{R}.
8259
8260 Theorem 1: @math{R(1)} lies between @math{L} and @math{L(next)},
8261 i.e. @math{L <= R(1) < L(next)}.
8262
8263   This follows easily from the definition of display order.  The
8264 basic reason that this theorem applies is that the display order
8265 sorts by increasing starting index.
8266
8267   Therefore, we can determine @math{L} just by looking at where we would
8268 insert @math{R(1)} into the list, and if we know @math{F} and are moving
8269 forward over extents, we can easily determine when we've hit @math{L} by
8270 comparing the extent we're at to @math{R(1)}.
8271
8272 @example
8273 Theorem 2: @math{F(e-prev) e< [1, R(0)] e<= F}.
8274 @end example
8275
8276   This is the analog of Theorem 1, and applies because the e-order
8277 sorts by increasing ending index.
8278
8279   Therefore, @math{F} can be found in the same amount of time as
8280 operation (1), i.e. the time that it takes to locate where an extent
8281 would go if inserted into the e-order list.
8282
8283   If the lists were stored as balanced binary trees, then operation (1)
8284 would take logarithmic time, which is usually quite fast.  However,
8285 currently they're stored as simple doubly-linked lists, and instead we
8286 do some caching to try to speed things up.
8287
8288   Define a @dfn{stack of extents} (or @dfn{SOE}) as the set of extents
8289 (ordered in the display order) that overlap an index @math{I}, together
8290 with the SOE's @dfn{previous} extent, which is an extent that precedes
8291 @math{I} in the e-order. (Hopefully there will not be very many extents
8292 between @math{I} and the previous extent.)
8293
8294 Now:
8295
8296 Let @math{I} be an index, let @math{S} be the stack of extents on
8297 @math{I}, let @math{F} be the first extent in @math{S}, and let @math{P}
8298 be @math{S}'s previous extent.
8299
8300 Theorem 3: The first extent in @math{S} is the first extent that overlaps
8301 any range @math{[I, J]}.
8302
8303 Proof: Any extent that overlaps @math{[I, J]} but does not include
8304 @math{I} must have a start index @math{> I}, and thus be greater than
8305 any extent in @math{S}.
8306
8307 Therefore, finding the first extent that overlaps a range @math{R} is
8308 the same as finding the first extent that overlaps @math{R(0)}.
8309
8310 Theorem 4: Let @math{I2} be an index such that @math{I2 > I}, and let
8311 @math{F2} be the first extent that overlaps @math{I2}.  Then, either
8312 @math{F2} is in @math{S} or @math{F2} is greater than any extent in
8313 @math{S}.
8314
8315 Proof: If @math{F2} does not include @math{I} then its start index is
8316 greater than @math{I} and thus it is greater than any extent in
8317 @math{S}, including @math{F}.  Otherwise, @math{F2} includes @math{I}
8318 and thus is in @math{S}, and thus @math{F2 >= F}.
8319
8320 @node Extent Fragments
8321 @section Extent Fragments
8322 @cindex extent fragment
8323
8324   Imagine that the buffer is divided up into contiguous, non-overlapping
8325 @dfn{runs} of text such that no extent starts or ends within a run
8326 (extents that abut the run don't count).
8327
8328   An extent fragment is a structure that holds data about the run that
8329 contains a particular buffer position (if the buffer position is at the
8330 junction of two runs, the run after the position is used) -- the
8331 beginning and end of the run, a list of all of the extents in that run,
8332 the @dfn{merged face} that results from merging all of the faces
8333 corresponding to those extents, the begin and end glyphs at the
8334 beginning of the run, etc.  This is the information that redisplay needs
8335 in order to display this run.
8336
8337   Extent fragments have to be very quick to update to a new buffer
8338 position when moving linearly through the buffer.  They rely on the
8339 stack-of-extents code, which does the heavy-duty algorithmic work of
8340 determining which extents overly a particular position.
8341
8342 @node Faces, Glyphs, Extents, Top
8343 @chapter Faces
8344
8345 Not yet documented.
8346
8347 @node Glyphs, Specifiers, Faces, Top
8348 @chapter Glyphs
8349
8350 Glyphs are graphical elements that can be displayed in XEmacs buffers or
8351 gutters. We use the term graphical element here in the broadest possible
8352 sense since glyphs can be as mundane as text to as arcane as a native
8353 tab widget.
8354
8355 In XEmacs, glyphs represent the uninstantiated state of graphical
8356 elements, i.e. they hold all the information necessary to produce an
8357 image on-screen but the image does not exist at this stage.
8358
8359 Glyphs are lazily instantiated by calling one of the glyph
8360 functions. This usually occurs within redisplay when
8361 @code{Fglyph_height} is called. Instantiation causes an image-instance
8362 to be created and cached. This cache is on a device basis for all glyphs
8363 except glyph-widgets, and on a window basis for glyph widgets.  The
8364 caching is done by @code{image_instantiate} and is necessary because it
8365 is generally possible to display an image-instance in multiple
8366 domains. For instance if we create a Pixmap, we can actually display
8367 this on multiple windows - even though we only need a single Pixmap
8368 instance to do this. If caching wasn't done then it would be necessary
8369 to create image-instances for every displayable occurrance of a glyph -
8370 and every usage - and this would be extremely memory and cpu intensive.
8371
8372 Widget-glyphs (a.k.a native widgets) are not cached in this way. This is
8373 because widget-glyph image-instances on screen are toolkit windows, and
8374 thus cannot be reused in multiple XEmacs domains. Thus widget-glyphs are
8375 cached on a window basis.
8376
8377 Any action on a glyph first consults the cache before actually
8378 instantiating a widget.
8379
8380 @section Widget-Glyphs in the MS-WIndows Environment
8381
8382 To Do
8383
8384 @section Widget-Glyphs in the X Environment
8385
8386 Widget-glyphs under X make heavy use of lwlib for manipulating the
8387 native toolkit objects. This is primarily so that different toolkits can
8388 be supported for widget-glyphs, just as they are supported for features
8389 such as menubars etc.
8390
8391 Lwlib is extremely poorly documented and quite hairy so here is my
8392 understanding of what goes on.
8393
8394 Lwlib maintains a set of widget_instances which mirror the hierarchical
8395 state of Xt widgets. I think this is so that widgets can be updated and
8396 manipulated generically by the lwlib library. For instance
8397 update_one_widget_instance can cope with multiple types of widget and
8398 multiple types of toolkit. Each element in the widget hierarchy is updated
8399 from its corresponding widget_instance by walking the widget_instance
8400 tree recursively.
8401
8402 This has desirable properties such as lw_modify_all_widgets which is
8403 called from glyphs-x.c and updates all the properties of a widget
8404 without having to know what the widget is or what toolkit it is from.
8405 Unfortunately this also has hairy properrties such as making the lwlib
8406 code quite complex. And of course lwlib has to know at some level what
8407 the widget is and how to set its properties.
8408
8409 @node Specifiers, Menus, Glyphs, Top
8410 @chapter Specifiers
8411
8412 Not yet documented.
8413
8414 @node Menus, Subprocesses, Specifiers, Top
8415 @chapter Menus
8416
8417   A menu is set by setting the value of the variable
8418 @code{current-menubar} (which may be buffer-local) and then calling
8419 @code{set-menubar-dirty-flag} to signal a change.  This will cause the
8420 menu to be redrawn at the next redisplay.  The format of the data in
8421 @code{current-menubar} is described in @file{menubar.c}.
8422
8423   Internally the data in current-menubar is parsed into a tree of
8424 @code{widget_value's} (defined in @file{lwlib.h}); this is accomplished
8425 by the recursive function @code{menu_item_descriptor_to_widget_value()},
8426 called by @code{compute_menubar_data()}.  Such a tree is deallocated
8427 using @code{free_widget_value()}.
8428
8429   @code{update_screen_menubars()} is one of the external entry points.
8430 This checks to see, for each screen, if that screen's menubar needs to
8431 be updated.  This is the case if
8432
8433 @enumerate
8434 @item
8435 @code{set-menubar-dirty-flag} was called since the last redisplay.  (This
8436 function sets the C variable menubar_has_changed.)
8437 @item
8438 The buffer displayed in the screen has changed.
8439 @item
8440 The screen has no menubar currently displayed.
8441 @end enumerate
8442
8443   @code{set_screen_menubar()} is called for each such screen.  This
8444 function calls @code{compute_menubar_data()} to create the tree of
8445 widget_value's, then calls @code{lw_create_widget()},
8446 @code{lw_modify_all_widgets()}, and/or @code{lw_destroy_all_widgets()}
8447 to create the X-Toolkit widget associated with the menu.
8448
8449   @code{update_psheets()}, the other external entry point, actually
8450 changes the menus being displayed.  It uses the widgets fixed by
8451 @code{update_screen_menubars()} and calls various X functions to ensure
8452 that the menus are displayed properly.
8453
8454   The menubar widget is set up so that @code{pre_activate_callback()} is
8455 called when the menu is first selected (i.e. mouse button goes down),
8456 and @code{menubar_selection_callback()} is called when an item is
8457 selected.  @code{pre_activate_callback()} calls the function in
8458 activate-menubar-hook, which can change the menubar (this is described
8459 in @file{menubar.c}).  If the menubar is changed,
8460 @code{set_screen_menubars()} is called.
8461 @code{menubar_selection_callback()} enqueues a menu event, putting in it
8462 a function to call (either @code{eval} or @code{call-interactively}) and
8463 its argument, which is the callback function or form given in the menu's
8464 description.
8465
8466 @node Subprocesses, Interface to X Windows, Menus, Top
8467 @chapter Subprocesses
8468
8469   The fields of a process are:
8470
8471 @table @code
8472 @item name
8473 A string, the name of the process.
8474
8475 @item command
8476 A list containing the command arguments that were used to start this
8477 process.
8478
8479 @item filter
8480 A function used to accept output from the process instead of a buffer,
8481 or @code{nil}.
8482
8483 @item sentinel
8484 A function called whenever the process receives a signal, or @code{nil}.
8485
8486 @item buffer
8487 The associated buffer of the process.
8488
8489 @item pid
8490 An integer, the Unix process @sc{id}.
8491
8492 @item childp
8493 A flag, non-@code{nil} if this is really a child process.
8494 It is @code{nil} for a network connection.
8495
8496 @item mark
8497 A marker indicating the position of the end of the last output from this
8498 process inserted into the buffer.  This is often but not always the end
8499 of the buffer.
8500
8501 @item kill_without_query
8502 If this is non-@code{nil}, killing XEmacs while this process is still
8503 running does not ask for confirmation about killing the process.
8504
8505 @item raw_status_low
8506 @itemx raw_status_high
8507 These two fields record 16 bits each of the process status returned by
8508 the @code{wait} system call.
8509
8510 @item status
8511 The process status, as @code{process-status} should return it.
8512
8513 @item tick
8514 @itemx update_tick
8515 If these two fields are not equal, a change in the status of the process
8516 needs to be reported, either by running the sentinel or by inserting a
8517 message in the process buffer.
8518
8519 @item pty_flag
8520 Non-@code{nil} if communication with the subprocess uses a @sc{pty};
8521 @code{nil} if it uses a pipe.
8522
8523 @item infd
8524 The file descriptor for input from the process.
8525
8526 @item outfd
8527 The file descriptor for output to the process.
8528
8529 @item subtty
8530 The file descriptor for the terminal that the subprocess is using.  (On
8531 some systems, there is no need to record this, so the value is
8532 @code{-1}.)
8533
8534 @item tty_name
8535 The name of the terminal that the subprocess is using,
8536 or @code{nil} if it is using pipes.
8537 @end table
8538
8539 @node Interface to X Windows, Index, Subprocesses, Top
8540 @chapter Interface to X Windows
8541
8542 Not yet documented.
8543
8544 @include index.texi
8545
8546 @c Print the tables of contents
8547 @summarycontents
8548 @contents
8549 @c That's all
8550
8551 @bye
8552