Mercurial > hg > xemacs-beta
annotate src/emacs.c @ 4614:afbfad080ddd
The URLs in our current config.guess and config.sub files are obsolete.
Update to the latest upstream release to get correct URLs, as well as fixes
and enhancements to those scripts.
| author | Jerry James <james@xemacs.org> |
|---|---|
| date | Wed, 11 Feb 2009 11:09:35 -0700 |
| parents | 726060ee587c |
| children | 80cd90837ac5 |
| rev | line source |
|---|---|
| 428 | 1 /* XEmacs -- Fully extensible Emacs, running on Unix and other platforms. |
| 2 Copyright (C) 1985, 1986, 1987, 1992, 1993, 1994 | |
| 3 Free Software Foundation, Inc. | |
| 4 Copyright (C) 1995 Sun Microsystems, Inc. | |
| 3024 | 5 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 Ben Wing. |
| 428 | 6 |
| 7 This file is part of XEmacs. | |
| 8 | |
| 9 XEmacs is free software; you can redistribute it and/or modify it | |
| 10 under the terms of the GNU General Public License as published by the | |
| 11 Free Software Foundation; either version 2, or (at your option) any | |
| 12 later version. | |
| 13 | |
| 14 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 17 for more details. | |
| 18 | |
| 19 You should have received a copy of the GNU General Public License | |
| 20 along with XEmacs; see the file COPYING. If not, write to | |
| 21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 22 Boston, MA 02111-1307, USA. */ | |
| 23 | |
| 24 /* Synched up with: Mule 2.0, FSF 19.28. */ | |
| 25 | |
| 2367 | 26 /* This file has been Mule-ized, Ben Wing, 10-7-04. */ |
| 27 | |
| 442 | 28 /* Capsule summary of the various releases of Lucid Emacs/XEmacs and |
| 771 | 29 FSF/GNU Emacs. (Copied from the Internals Manual, where the |
| 30 canonical version lives.) Provided here for use in cross-referencing | |
| 31 version releases and dates in comments, esp. in the authorship | |
| 32 comments at the beginning of each file. More information about | |
| 33 history can be found in the beginning of the Internals Manual and | |
| 34 in the About page. | |
| 442 | 35 |
| 36 | |
| 37 -- A time line for Lucid Emacs/XEmacs is | |
| 38 | |
| 2517 | 39 Version 19.0 shipped with Energize 1.0, April 1992. |
| 40 Version 19.1 released June 4, 1992. | |
| 41 Version 19.2 released June 19, 1992. | |
| 42 Version 19.3 released September 9, 1992. | |
| 43 Version 19.4 released January 21, 1993. | |
| 44 Version 19.5 released February 5, 1993. This was a repackaging of 19.4 with a | |
| 45 few bug fixes and shipped with Energize 2.0. It was a trade-show giveaway | |
| 46 and never released to the net. | |
| 47 Version 19.6 released April 9, 1993. | |
| 48 Version 19.7 was a repackaging of 19.6 with a few bug fixes and | |
| 442 | 49 shipped with Energize 2.1. Never released to the net. |
| 2517 | 50 Version 19.8 released September 6, 1993. (Epoch merger, preliminary I18N |
| 51 support) | |
| 52 Version 19.9 released January 12, 1994. (Scrollbars, Athena.) | |
| 53 Version 19.10 released May 27, 1994. Known as "Lucid Emacs" when | |
| 54 shipped by Lucid, and as "XEmacs" when shipped by Sun; but Lucid | |
| 55 went out of business a few days later and it's unclear very many | |
| 56 copies of 19.10 were released by Lucid. (Last release by Jamie Zawinski.) | |
| 57 Version 19.11 (first XEmacs) released September 13, 1994. | |
| 58 Version 19.12 released June 23, 1995. | |
| 59 Version 19.13 released September 1, 1995. | |
| 60 Version 19.14 released June 23, 1996. | |
| 61 Version 20.0 released February 9, 1997. | |
| 62 Version 19.15 released March 28, 1997. | |
| 63 Version 20.1 (not released to the net) April 15, 1997. | |
| 64 Version 20.2 released May 16, 1997. | |
| 65 Version 19.16 released October 31, 1997; retiring of v19 series. | |
| 66 Version 20.3 (the first stable version of XEmacs 20.x) released November 30, | |
| 67 1997. | |
| 68 Version 20.4 released February 28, 1998. (Jamie claims this version is the | |
| 69 "first reasonably stable release with MULE support" and says that "XEmacs | |
| 70 'core' and 'packages' now packaged separately.") | |
| 71 Version 21.0-pre5 released July 18, 1998. (Jamie says "Numbering scheme goes | |
| 72 wonky due to switch to stable + unstable branches.") | |
| 73 Version 21.0.60 released December 10, 1998. (The version naming scheme was | |
| 74 changed at this point: [a] the second version number is odd for stable | |
| 75 versions, even for beta versions; [b] a third version number is added, | |
| 76 replacing the "beta xxx" ending for beta versions and allowing for | |
| 77 periodic maintenance releases for stable versions. Therefore, 21.0 was | |
| 78 never "officially" released; similarly for 21.2, etc.) | |
| 79 Version 21.0.61 released January 4, 1999. | |
| 80 Version 21.0.63 released February 3, 1999. | |
| 81 Version 21.0.64 released March 1, 1999. | |
| 82 Version 21.0.65 released March 5, 1999. | |
| 83 Version 21.0.66 released March 12, 1999. | |
| 84 Version 21.0.67 released March 25, 1999. | |
| 85 Version 21.1.2 released May 14, 1999; on comp.emacs, May 28. (This is | |
| 788 | 86 the followup to 21.0.67. The second version number was bumped to indicate |
| 87 the beginning of the "stable" series.) | |
| 2517 | 88 Version 21.1.3 released June 26, 1999. |
| 89 Version 21.1.4 released July 8, 1999. | |
| 90 Version 21.1.6 released August 14, 1999. (There was no 21.1.5.) | |
| 91 Version 21.1.7 released September 26, 1999. | |
| 92 Version 21.1.8 released November 2, 1999. | |
| 93 Version 21.1.9 released February 13, 2000. | |
| 94 Version 21.1.10 released May 7, 2000. | |
| 95 Version 21.1.10a released June 24, 2000. | |
| 96 Version 21.1.11 released July 18, 2000. | |
| 97 Version 21.1.12 released August 5, 2000. | |
| 98 Version 21.1.13 released January 7, 2001. | |
| 99 Version 21.1.14 released January 27, 2001. | |
| 100 Version 21.2.9 released February 3, 1999. | |
| 101 Version 21.2.10 released February 5, 1999. | |
| 102 Version 21.2.11 released March 1, 1999. | |
| 103 Version 21.2.12 released March 5, 1999. | |
| 104 Version 21.2.13 released March 12, 1999. | |
| 105 Version 21.2.14 released May 14, 1999. | |
| 106 Version 21.2.15 released June 4, 1999. | |
| 107 Version 21.2.16 released June 11, 1999. | |
| 108 Version 21.2.17 released June 22, 1999. | |
| 109 Version 21.2.18 released July 14, 1999. | |
| 110 Version 21.2.19 released July 30, 1999. | |
| 111 Version 21.2.20 released November 10, 1999. | |
| 112 Version 21.2.21 released November 28, 1999. | |
| 113 Version 21.2.22 released November 29, 1999. | |
| 114 Version 21.2.23 released December 7, 1999. | |
| 115 Version 21.2.24 released December 14, 1999. | |
| 116 Version 21.2.25 released December 24, 1999. | |
| 117 Version 21.2.26 released December 31, 1999. | |
| 118 Version 21.2.27 released January 18, 2000. | |
| 119 Version 21.2.28 released February 7, 2000. | |
| 120 Version 21.2.29 released February 16, 2000. | |
| 121 Version 21.2.30 released February 21, 2000. | |
| 122 Version 21.2.31 released February 23, 2000. | |
| 123 Version 21.2.32 released March 20, 2000. | |
| 124 Version 21.2.33 released May 1, 2000. | |
| 125 Version 21.2.34 released May 28, 2000. | |
| 126 Version 21.2.35 released July 19, 2000. | |
| 127 Version 21.2.36 released October 4, 2000. | |
| 128 Version 21.2.37 released November 14, 2000. | |
| 129 Version 21.2.38 released December 5, 2000. | |
| 130 Version 21.2.39 released December 31, 2000. | |
| 131 Version 21.2.40 released January 8, 2001. | |
| 132 Version 21.2.41 "Polyhymnia" released January 17, 2001. | |
| 133 Version 21.2.42 "Poseidon" released January 20, 2001. | |
| 134 Version 21.2.43 "Terspichore" released January 26, 2001. | |
| 135 Version 21.2.44 "Thalia" released February 8, 2001. | |
| 136 Version 21.2.45 "Thelxepeia" released February 23, 2001. | |
| 137 Version 21.2.46 "Urania" released March 21, 2001. | |
| 138 Version 21.2.47 "Zephir" released April 14, 2001. | |
| 139 Version 21.4.0 "Solid Vapor" released April 16, 2001. | |
| 140 Version 21.4.1 "Copyleft" released April 19, 2001. | |
| 141 Version 21.4.2 "Developer-Friendly Unix APIs" released May 10, 2001. | |
| 142 Version 21.4.3 "Academic Rigor" released May 17, 2001. | |
| 143 Version 21.4.4 "Artificial Intelligence" released July 28, 2001. | |
| 144 Version 21.4.5 "Civil Service" released October 23, 2001. | |
| 145 Version 21.4.6 "Common Lisp" released December 17, 2001. | |
| 146 Version 21.4.7 "Economic Science" released May 4, 2002. | |
| 147 Version 21.4.8 "Honest Recruiter" released May 9, 2002. | |
| 148 Version 21.4.9 "Informed Management" released August 23, 2002. | |
| 149 Version 21.4.10 "Military Intelligence" released November 2, 2002. | |
| 150 Version 21.4.11 "Native Windows TTY Support" released January 3, 2003. | |
| 151 Version 21.4.12 "Portable Code" released January 15, 2003. | |
| 152 Version 21.4.13 "Rational FORTRAN" released May 25, 2003. | |
| 153 Version 21.4.14 "Reasonable Discussion" released September 3, 2003. | |
| 154 Version 21.4.15 "Security Through Obscurity" released February 2, 2004. | |
| 155 Version 21.5.0 "alfalfa" released April 18, 2001. | |
| 156 Version 21.5.1 "anise" released May 9, 2001. | |
| 157 Version 21.5.2 "artichoke" released July 28, 2001. | |
| 158 Version 21.5.3 "asparagus" released September 7, 2001. | |
| 159 Version 21.5.4 "bamboo" released January 8, 2002. | |
| 160 Version 21.5.5 "beets" released March 5, 2002. | |
| 161 Version 21.5.6 "bok choi" released April 5, 2002. | |
| 162 Version 21.5.7 "broccoflower" released July 2, 2002. | |
| 163 Version 21.5.8 "broccoli" released July 27, 2002. | |
| 164 Version 21.5.9 "brussels sprouts" released August 30, 2002. | |
| 165 Version 21.5.10 "burdock" released January 4, 2003. | |
| 166 Version 21.5.11 "cabbage" released February 16, 2003. | |
| 167 Version 21.5.12 "carrot" released April 24, 2003. | |
| 168 Version 21.5.13 "cauliflower" released May 10, 2003. | |
| 169 Version 21.5.14 "cassava" released June 1, 2003. | |
| 170 Version 21.5.15 "celery" released September 3, 2003. | |
| 171 Version 21.5.16 "celeriac" released September 26, 2003. | |
| 172 Version 21.5.17 "chayote" released March 22, 2004. | |
| 173 Version 21.5.18 "chestnut" released October 22, 2004. | |
| 442 | 174 |
| 175 | |
| 176 -- A time line for GNU Emacs version 19 is | |
| 177 | |
| 178 version 19.7 (beta) (first beta release) released ??????; prob. late May 1993. | |
| 179 version 19.8 (beta) released May 27, 1993. | |
| 180 version 19.9 (beta) released May 27, 1993. | |
| 181 version 19.10 (beta) released May 30, 1993. | |
| 182 version 19.11 (beta) released June 1, 1993. | |
| 183 version 19.12 (beta) released June 2, 1993. | |
| 184 version 19.13 (beta) released June 8, 1993. | |
| 185 version 19.14 (beta) released June 17, 1993. | |
| 186 version 19.15 (beta) released June 19, 1993. | |
| 187 version 19.16 (beta) released July 6, 1993. | |
| 188 version 19.17 (beta) released late July, 1993. | |
| 189 version 19.18 (beta) released August 9, 1993. | |
| 190 version 19.19 (beta) released August 15, 1993. | |
| 191 version 19.20 (beta) released November 17, 1993. | |
| 192 version 19.21 (beta) released November 17, 1993. | |
| 193 version 19.22 (beta) released November 28, 1993. | |
| 788 | 194 version 19.23 (beta) released on comp.emacs, May 17, 1994. |
| 442 | 195 version 19.24 (beta) released May 16, 1994. |
| 196 version 19.25 (beta) released June 3, 1994. | |
| 197 version 19.26 (beta) released September 11, 1994. | |
| 198 version 19.27 (beta) released September 14, 1994. | |
| 199 version 19.28 (first ``official'' release) released November 1, 1994. | |
| 200 version 19.29 released June 21, 1995. | |
| 201 version 19.30 released November 24, 1995. | |
| 202 version 19.31 released May 25, 1996. | |
| 203 version 19.32 released July 31, 1996. | |
| 204 version 19.33 released August 11, 1996. | |
| 788 | 205 version 19.34 released August 21, 1996; on comp.emacs, August 22. |
| 442 | 206 version 19.34b released September 6, 1996. |
| 207 | |
| 208 | |
| 788 | 209 -- A time line for GNU Emacs versions 20 and 21 is |
| 442 | 210 |
| 211 version 20.1 released September 17, 1997. | |
| 212 version 20.2 released September 20, 1997. | |
| 213 version 20.3 released August 19, 1998. | |
| 788 | 214 version 20.4 released July 12, 1999; on comp.emacs, July 27. |
| 215 version 21.1 released October 20, 2001. | |
| 2517 | 216 Version 21.2 released March 16, 2002. |
| 217 Version 21.3 released March 19, 2003. | |
| 442 | 218 |
| 219 | |
| 220 -- A time line for GNU Emacs version 18 and older is | |
| 221 | |
| 222 GNU Emacs version 15 (15.34) was released sometime in 1984 or 1985 and | |
| 223 shared some code with a version of Emacs written by James Gosling (the | |
| 224 same James Gosling who later created the Java language). | |
| 225 GNU Emacs version 16 (first released version was 16.56) was released on | |
| 226 July 15, 1985. All Gosling code was removed due to potential copyright | |
| 227 problems with the code. | |
| 228 version 16.57: released on September 16, 1985. | |
| 229 versions 16.58, 16.59: released on September 17, 1985. | |
| 230 version 16.60: released on September 19, 1985. These later version 16's | |
| 231 incorporated patches from the net, esp. for getting Emacs to work under | |
| 232 System V. | |
| 233 version 17.36 (first official v17 release) released on December 20, 1985. | |
| 234 Included a TeX-able user manual. First official unpatched version that | |
| 235 worked on vanilla System V machines. | |
| 236 version 17.43 (second official v17 release) released on January 25, 1986. | |
| 237 version 17.45 released on January 30, 1986. | |
| 238 version 17.46 released on February 4, 1986. | |
| 239 version 17.48 released on February 10, 1986. | |
| 240 version 17.49 released on February 12, 1986. | |
| 241 version 17.55 released on March 18, 1986. | |
| 242 version 17.57 released on March 27, 1986. | |
| 243 version 17.58 released on April 4, 1986. | |
| 244 version 17.61 released on April 12, 1986. | |
| 245 version 17.63 released on May 7, 1986. | |
| 246 version 17.64 released on May 12, 1986. | |
| 247 version 18.24 (a beta version) released on October 2, 1986. | |
| 248 version 18.30 (a beta version) released on November 15, 1986. | |
| 249 version 18.31 (a beta version) released on November 23, 1986. | |
| 250 version 18.32 (a beta version) released on December 7, 1986. | |
| 251 version 18.33 (a beta version) released on December 12, 1986. | |
| 252 version 18.35 (a beta version) released on January 5, 1987. | |
| 253 version 18.36 (a beta version) released on January 21, 1987. | |
| 254 January 27, 1987: The Great Usenet Renaming. net.emacs is now comp.emacs. | |
| 255 version 18.37 (a beta version) released on February 12, 1987. | |
| 256 version 18.38 (a beta version) released on March 3, 1987. | |
| 257 version 18.39 (a beta version) released on March 14, 1987. | |
| 258 version 18.40 (a beta version) released on March 18, 1987. | |
| 259 version 18.41 (the first ``official'' release) released on March 22, 1987. | |
| 260 version 18.45 released on June 2, 1987. | |
| 261 version 18.46 released on June 9, 1987. | |
| 262 version 18.47 released on June 18, 1987. | |
| 263 version 18.48 released on September 3, 1987. | |
| 264 version 18.49 released on September 18, 1987. | |
| 265 version 18.50 released on February 13, 1988. | |
| 266 version 18.51 released on May 7, 1988. | |
| 267 version 18.52 released on September 1, 1988. | |
| 268 version 18.53 released on February 24, 1989. | |
| 269 version 18.54 released on April 26, 1989. | |
| 270 version 18.55 released on August 23, 1989. This is the earliest version | |
| 271 that is still available by FTP. | |
| 272 version 18.56 released on January 17, 1991. | |
| 273 version 18.57 released late January, 1991. | |
| 274 version 18.58 released ?????. | |
| 275 version 18.59 released October 31, 1992. | |
| 276 | |
| 2517 | 277 |
| 278 -- A time line for Epoch is | |
| 279 | |
| 280 Epoch 1.0 released December 14, 1989. (by Simon Kaplan, Chris Love, et al.) | |
| 281 Epoch 2.0 released December 23, 1989. | |
| 282 Epoch 3.1 released February 6, 1990. | |
| 283 Epoch 3.2 released December[????] 11, 1990. | |
| 284 Epoch 4.0 released August 27, 1990. | |
| 285 | |
| 442 | 286 */ |
| 854 | 287 |
| 2367 | 288 /* Sources for further information: |
| 289 | |
| 290 ----------------------------------- | |
| 291 1. Using XEmacs, Programming Elisp: | |
| 292 ----------------------------------- | |
| 293 | |
| 294 ;;; -- the XEmacs User's Manual (Access using the online Info browser: | |
| 295 ;;; Use `Help->Info (Online Docs)->XEmacs User's Manual' (if | |
| 296 ;;; there is such an entry); or get to the Info contents page | |
| 297 ;;; using `Help->Info Contents' or `C-h i', and then | |
| 298 ;;; *middle-click* the XEmacs link or move the cursor into the | |
| 299 ;;; link and hit ENTER. This manual contains a great deal of | |
| 300 ;;; documentation on customization: Scroll down to the | |
| 301 ;;; Customization link and select it in the same fashion as for | |
| 302 ;;; the XEmacs link just mentioned.) | |
| 303 | |
| 304 ;;; -- the XEmacs FAQ (`C-h F' for the local version; get either the | |
| 305 ;;; local version or the very latest version off the net using | |
| 306 ;;; the Help menu) | |
| 307 | |
| 308 ;;; -- the XEmacs Lisp Reference Manual, containing detailed | |
| 309 ;;; documentation on Elisp. (Access using Info, just like for the | |
| 310 ;;; XEmacs User's Manual.) | |
| 311 | |
| 312 ;;; -- the documentation strings for specific commands, functions, | |
| 313 ;;; key sequences, and variables. NOTE: This is *not* the same | |
| 314 ;;; information as in the XEmacs User's Manual or XEmacs Lisp | |
| 315 ;;; Reference Manual! In general, the doc strings are more | |
| 316 ;;; terse and more up-to-date than what is found in the manuals. | |
| 317 ;;; Once you understand the general concepts, these doc strings | |
| 318 ;;; should be your first point of reference for further | |
| 319 ;;; info. (Access using menu entries under `Help->Commands, | |
| 320 ;;; Variables, Keys' or using the keyboard: `C-h k' for a key | |
| 321 ;;; sequence, `C-h f' for a named command or Elisp function, | |
| 322 ;;; `C-h v' for a variable. There is various other useful | |
| 323 ;;; information accessible similarly, such as `C-h a' | |
| 324 ;;; ["Apropos", i.e. search for a command, function, or variable | |
| 325 ;;; by name]; `C-h C-a' ["Apropos Docs", i.e. search through the | |
| 326 ;;; text of the doc strings]; `C-h b' to list all key bindings; | |
| 327 ;;; `C-h m' to describe the current major and minor modes; etc. | |
| 328 ;;; Type `C-h ? ?' for a complete list.) | |
| 329 | |
| 330 ;;; -- Getting Started with XEmacs [aka the "New User's Guide"], a | |
| 331 ;;; more introductory manual than the XEmacs User's Manual. | |
| 332 ;;; (Access using Info, just like for the XEmacs User's Manual. | |
| 333 ;;; There are some sections on customization here.) | |
| 334 | |
| 335 ;;; -- the XEmacs tutorial, a very simple introduction to XEmacs for | |
| 336 ;;; total beginners. (`C-h t' for English; get the version in | |
| 337 ;;; various languages from the Help menu) | |
| 338 | |
| 339 ;;; -- the XEmacs web site, www.xemacs.org. | |
| 340 | |
| 341 ;;; -- the XEmacs mailing lists (xemacs-FOO@xemacs.org; | |
| 342 ;;; see http://www.xemacs.org/Lists/ for more info. Before | |
| 343 ;;; posting, consider looking through the archives -- they go back | |
| 344 ;;; years and there is a powerful searching interface. Currently | |
| 345 ;;; the archives are at http://list-archive.xemacs.org/, but if | |
| 346 ;;; this doesn't work, you can always access them through | |
| 347 ;;; www.xemacs.org.) | |
| 348 | |
| 349 ;;; -- the XEmacs newsgroup, comp.emacs.xemacs. This is | |
| 350 ;;; bi-directionally gatewayed with xemacs@xemacs.org. WARNING: | |
| 351 ;;; The developers do not normally hang out on this newsgroup. If | |
| 352 ;;; you need to contact them, use xemacs-beta@xemacs.org. | |
| 353 | |
| 354 ;;; -- the XEmacs internals manual, for those interested in working on | |
| 355 ;;; the XEmacs C code. (Available through Info.) | |
| 356 | |
| 357 ;;; -- `Help->About XEmacs' to find out who the maintainers are. | |
| 358 | |
| 359 --------------------- | |
| 360 2. Developing XEmacs: | |
| 361 --------------------- | |
| 362 | |
| 363 -- the internals manual, man/internals/internals.texi | |
| 364 | |
| 365 -- long comments at the head of certain files: | |
| 366 | |
| 367 emacs.c | |
| 368 extents.c | |
| 369 text.c | |
| 370 text.h | |
| 371 lisp.h | |
| 372 redisplay.h | |
| 373 dynarr.c | |
| 374 blocktype.c | |
| 375 eval.c | |
| 376 event-Xt.c (sort of) | |
| 377 event-stream.c (command event queue) | |
| 378 frame.c | |
| 379 intl-encap-win32.c | |
| 380 keymap.c | |
| 381 line-number.c (a little bit) | |
| 382 menubar-msw.c (sort of) | |
| 383 menubar-x.c (sort of) | |
| 384 mule-canna.c (sort of) | |
| 385 mule-ccl.c | |
| 386 mule-coding.c (scattered in the file) | |
| 387 mule-wnn.c (in japanese) | |
| 388 ntheap.c (near the top) | |
| 389 redisplay.c (various scattered) | |
| 390 regex.c (various scattered) | |
| 391 sysdep.c (maybe; wait_for_termination) | |
| 392 unexec.c | |
| 393 unicode.c | |
| 394 xgccache.c (a bit) | |
| 395 | |
| 396 #### review .h files; write a perl program to look for long comments | |
| 397 throughout the files, ignoring stuff inside of DEFUN's. | |
| 398 | |
| 399 #### elsewhere? | |
| 400 | |
| 401 -- comments scattered throughout the sources (#### should be grouped | |
| 402 together if feasible). For example, lrecord.h (pdump and object- | |
| 403 creation), alloc.c (fixed-type allocation), etc. #### fill in. | |
| 404 | |
| 405 -- Ben's Architecting XEmacs web site. | |
| 406 (http://www.xemacs.org/Architecting-XEmacs/index.html; #### should be | |
| 407 integrated into the sources) | |
| 408 | |
| 409 -- Back discussions on xemacs-beta (#### The juiciest tidbits, esp. | |
| 410 those with specific proposals, should be extracted and stuck in | |
| 411 the source) | |
| 412 | |
| 413 -- README.* in the src/ directory (and maybe other directories) | |
| 414 | |
| 415 -- The ChangeLog files, sometimes. | |
| 416 | |
| 417 */ | |
| 418 | |
| 419 | |
| 420 | |
| 428 | 421 /* Note: It is necessary to specify <config.h> and not "config.h" in |
| 422 order for the --srcdir type of compilation to work properly. | |
| 423 Otherwise the config.h from the srcdir, rather than the one from | |
| 424 the build dir, will be used. */ | |
| 425 | |
| 426 #include <config.h> | |
| 427 #include "lisp.h" | |
| 428 | |
| 429 #include "backtrace.h" /* run-emacs-from-temacs needs this */ | |
| 430 #include "buffer.h" | |
| 431 #include "commands.h" | |
| 432 #include "console.h" | |
| 433 #include "process.h" | |
| 434 #include "redisplay.h" | |
| 438 | 435 #include "frame.h" |
| 428 | 436 #include "sysdep.h" |
| 437 | |
| 438 #include "systty.h" | |
| 439 #include "sysfile.h" | |
| 440 #include "systime.h" | |
| 771 | 441 #include "sysproc.h" /* for qxe_getpid() */ |
| 428 | 442 |
| 443 #ifdef QUANTIFY | |
| 444 #include <quantify.h> | |
| 445 #endif | |
| 446 | |
| 447 #ifdef HAVE_SHLIB | |
| 448 #include "sysdll.h" | |
| 449 #endif | |
| 450 | |
| 451 #ifdef TOOLTALK | |
| 442 | 452 #include TT_C_H_FILE |
| 428 | 453 #endif |
| 454 | |
| 1315 | 455 #ifdef WIN32_ANY |
| 872 | 456 #include "console-msw.h" |
| 428 | 457 #endif |
| 458 | |
| 2720 | 459 #ifdef DUMP_IN_EXEC |
| 2015 | 460 #ifndef WIN32_NATIVE |
| 461 #include "dump-data.h" | |
| 462 #endif | |
| 2720 | 463 #endif |
| 2015 | 464 |
| 428 | 465 /* For PATH_EXEC */ |
| 466 #include <paths.h> | |
| 467 | |
| 826 | 468 #if defined (HEAP_IN_DATA) && !defined (PDUMP) |
| 428 | 469 void report_sheap_usage (int die_if_pure_storage_exceeded); |
| 470 #endif | |
| 471 | |
| 472 #if !defined (SYSTEM_MALLOC) && !defined (DOUG_LEA_MALLOC) | |
| 473 extern void *(*__malloc_hook)(size_t); | |
| 474 extern void *(*__realloc_hook)(void *, size_t); | |
| 475 extern void (*__free_hook)(void *); | |
| 476 #endif /* not SYSTEM_MALLOC && not DOUG_LEA_MALLOC */ | |
| 477 | |
| 478 /* Command line args from shell, as list of strings */ | |
| 479 Lisp_Object Vcommand_line_args; | |
| 480 | |
| 481 /* Set nonzero after XEmacs has started up the first time. | |
| 482 Prevents reinitialization of the Lisp world and keymaps | |
| 483 on subsequent starts. */ | |
| 484 int initialized; | |
| 485 | |
| 486 #ifdef DOUG_LEA_MALLOC | |
| 487 # include <malloc.h> | |
| 488 /* Preserves a pointer to the memory allocated that copies that | |
| 489 static data inside glibc's malloc. */ | |
| 490 static void *malloc_state_ptr; | |
| 491 #endif /* DOUG_LEA_MALLOC */ | |
| 492 | |
| 493 # ifdef REL_ALLOC | |
| 494 void r_alloc_reinit (void); | |
| 495 # endif | |
| 496 | |
| 497 /* Variable whose value is symbol giving operating system type. */ | |
| 498 Lisp_Object Vsystem_type; | |
| 499 | |
| 500 /* Variable whose value is string giving configuration built for. */ | |
| 501 Lisp_Object Vsystem_configuration; | |
| 502 | |
| 503 /* Variable whose value is string containing the configuration options | |
| 504 XEmacs was built with. */ | |
| 505 Lisp_Object Vsystem_configuration_options; | |
| 506 | |
| 507 /* Version numbers and strings */ | |
| 508 Lisp_Object Vemacs_major_version; | |
| 509 Lisp_Object Vemacs_minor_version; | |
| 510 Lisp_Object Vemacs_patch_level; | |
| 511 Lisp_Object Vemacs_beta_version; | |
| 512 Lisp_Object Vxemacs_codename; | |
| 975 | 513 Lisp_Object Vxemacs_extra_name; |
| 2602 | 514 Lisp_Object Vxemacs_release_date; |
| 428 | 515 #ifdef INFODOCK |
| 516 Lisp_Object Vinfodock_major_version; | |
| 517 Lisp_Object Vinfodock_minor_version; | |
| 518 Lisp_Object Vinfodock_build_version; | |
| 519 #endif | |
| 520 | |
| 521 /* The path under which XEmacs was invoked. */ | |
| 522 Lisp_Object Vinvocation_path; | |
| 523 | |
| 524 /* The name under which XEmacs was invoked, with any leading directory | |
| 525 names discarded. */ | |
| 526 Lisp_Object Vinvocation_name; | |
| 527 | |
| 528 /* The directory name from which XEmacs was invoked. */ | |
| 529 Lisp_Object Vinvocation_directory; | |
| 530 | |
| 531 #if 0 /* FSFmacs */ | |
| 532 /* The directory name in which to find subdirs such as lisp and etc. | |
| 533 nil means get them only from PATH_LOADSEARCH. */ | |
| 534 Lisp_Object Vinstallation_directory; | |
| 535 #endif | |
| 536 | |
| 537 Lisp_Object Vemacs_program_name, Vemacs_program_version; | |
| 538 Lisp_Object Vexec_path; | |
| 539 Lisp_Object Vexec_directory, Vconfigure_exec_directory; | |
| 540 Lisp_Object Vlisp_directory, Vconfigure_lisp_directory; | |
| 460 | 541 Lisp_Object Vmule_lisp_directory, Vconfigure_mule_lisp_directory; |
| 428 | 542 Lisp_Object Vmodule_directory, Vconfigure_module_directory; |
| 543 Lisp_Object Vsite_module_directory, Vconfigure_site_module_directory; | |
| 544 Lisp_Object Vconfigure_package_path; | |
| 3179 | 545 Lisp_Object Vconfigure_early_package_directories; |
| 546 Lisp_Object Vconfigure_late_package_directories; | |
| 547 Lisp_Object Vconfigure_last_package_directories; | |
| 428 | 548 Lisp_Object Vdata_directory, Vconfigure_data_directory; |
| 549 Lisp_Object Vdoc_directory, Vconfigure_doc_directory; | |
| 550 Lisp_Object Vconfigure_lock_directory; | |
| 551 Lisp_Object Vdata_directory_list; | |
| 552 Lisp_Object Vconfigure_info_directory; | |
| 553 Lisp_Object Vsite_directory, Vconfigure_site_directory; | |
| 554 Lisp_Object Vconfigure_info_path; | |
| 555 Lisp_Object Vinternal_error_checking; | |
| 438 | 556 Lisp_Object Vmail_lock_methods, Vconfigure_mail_lock_method; |
| 428 | 557 |
| 558 /* The default base directory XEmacs is installed under. */ | |
| 559 Lisp_Object Vconfigure_exec_prefix_directory, Vconfigure_prefix_directory; | |
| 560 | |
| 561 /* If nonzero, set XEmacs to run at this priority. This is also used | |
| 562 in child_setup and sys_suspend to make sure subshells run at normal | |
| 563 priority. */ | |
| 458 | 564 Fixnum emacs_priority; |
| 428 | 565 |
| 442 | 566 /* Some FSF junk with running_asynch_code, to preserve the match |
| 567 data. Not necessary because we don't call process filters | |
| 568 asynchronously (i.e. from within QUIT). */ | |
| 428 | 569 |
| 570 /* If non-zero, a window-system was specified on the command line. */ | |
| 571 int display_arg; | |
| 572 | |
| 573 /* Type of display specified. We cannot use a Lisp symbol here because | |
| 574 Lisp symbols may not initialized at the time that we set this | |
| 575 variable. */ | |
| 2367 | 576 const Ascbyte *display_use; |
| 428 | 577 |
| 578 /* If non-zero, then the early error handler will only print the error | |
| 579 message and exit. */ | |
| 580 int suppress_early_error_handler_backtrace; | |
| 581 | |
| 582 /* An address near the bottom of the stack. | |
| 583 Tells GC how to save a copy of the stack. */ | |
| 2367 | 584 Rawbyte *stack_bottom; |
| 428 | 585 |
| 586 #ifdef USG_SHARED_LIBRARIES | |
| 587 /* If nonzero, this is the place to put the end of the writable segment | |
| 588 at startup. */ | |
| 589 | |
| 590 uintptr_t bss_end = 0; | |
| 591 #endif | |
| 592 | |
| 647 | 593 /* Number of bytes of writable memory we can expect to be able to get: |
| 594 Leave this as an unsigned int because it could potentially be 4G */ | |
| 2132 | 595 unsigned long lim_data; |
| 428 | 596 |
| 442 | 597 /* WARNING! |
| 598 | |
| 599 Some LISP-visible command-line options are set by XEmacs _before_ the | |
| 600 data is dumped in building a --pdump XEmacs, but used _after_ it is | |
| 446 | 601 restored in normal operation. Thus the dump-time values overwrite the |
| 602 values XEmacs is getting at runtime. Such variables must be saved | |
| 442 | 603 before loading the dumpfile, and restored afterward. |
| 604 | |
| 446 | 605 Therefore these variables may not be initialized in vars_of_emacs(). |
| 606 | |
| 607 The save/restore is done immediately before and after pdump_load() in | |
| 608 main_1(). See that function for the current list of protected variables. | |
| 609 | |
| 610 Note that saving/restoring is only necessary for a few variables that are | |
| 611 o command line arguments effective at runtime (as opposed to dump-time), | |
| 612 o parsed before pdump_load, and | |
| 613 o exported to Lisp via a DEFVAR. | |
| 442 | 614 */ |
| 615 | |
| 428 | 616 /* Nonzero means running XEmacs without interactive terminal. */ |
| 617 | |
| 618 int noninteractive; | |
| 619 | |
| 620 /* Value of Lisp variable `noninteractive'. | |
| 621 Normally same as C variable `noninteractive' | |
| 442 | 622 but nothing terrible happens if user sets this one. |
| 623 | |
| 624 Shadowed from the pdumper by `noninteractive'. */ | |
| 428 | 625 |
| 626 int noninteractive1; | |
| 627 | |
| 628 /* Nonzero means don't perform site-lisp searches at startup */ | |
| 629 int inhibit_site_lisp; | |
| 630 | |
| 631 /* Nonzero means don't perform site-modules searches at startup */ | |
| 632 int inhibit_site_modules; | |
| 633 | |
| 776 | 634 /* Nonzero means don't load user-init or site-start file */ |
| 635 int vanilla_inhibiting; | |
| 636 | |
| 428 | 637 /* Nonzero means don't respect early packages at startup */ |
| 638 int inhibit_early_packages; | |
| 639 | |
| 776 | 640 /* Nonzero means don't respect any packages at startup -- act as if they |
| 641 don't exist. */ | |
| 642 int inhibit_all_packages; | |
| 643 | |
| 428 | 644 /* Nonzero means don't load package autoloads at startup */ |
| 645 int inhibit_autoloads; | |
| 646 | |
| 442 | 647 /* Nonzero means don't load the dump file (ignored if not PDUMP) */ |
| 648 | |
| 649 int nodumpfile; | |
| 650 | |
| 428 | 651 /* Nonzero means print debug information about path searching */ |
| 652 int debug_paths; | |
| 653 | |
| 654 /* Save argv and argc. */ | |
| 2367 | 655 static Wexttext **initial_argv; /* #### currently unused */ |
| 444 | 656 static int initial_argc; /* #### currently unused */ |
| 428 | 657 |
| 2367 | 658 static void sort_args (int argc, Wexttext **argv); |
| 428 | 659 |
| 660 Lisp_Object Qkill_emacs_hook; | |
| 661 Lisp_Object Qsave_buffers_kill_emacs; | |
| 662 | |
| 1315 | 663 Lisp_Object Qtemacs, Qdumping, Qrestarted, Qpdump, Qbatch; |
| 664 | |
| 442 | 665 /* Nonzero if handling a fatal error already. */ |
| 666 int fatal_error_in_progress; | |
| 667 | |
| 771 | 668 /* Nonzero means we're going down, so we better not run any hooks |
| 442 | 669 or do other non-essential stuff. */ |
| 670 int preparing_for_armageddon; | |
| 671 | |
| 771 | 672 /* Nonzero means we're in an unstable situation and need to skip |
| 2367 | 673 i18n conversions and such. During printing we check for this, |
| 674 and during conversion we abort if we see this. */ | |
| 675 int inhibit_non_essential_conversion_operations; | |
| 442 | 676 |
| 677 static JMP_BUF run_temacs_catch; | |
| 678 | |
| 679 static int run_temacs_argc; | |
| 2367 | 680 static Wexttext **run_temacs_argv; |
| 442 | 681 |
| 682 #ifdef _MSC_VER | |
| 771 | 683 static DWORD mswindows_handle_hardware_exceptions (DWORD code); |
| 684 #endif | |
| 442 | 685 |
| 826 | 686 #ifdef WIN32_NATIVE |
| 687 static DWORD CALLBACK wait_for_termination_signal (LPVOID handle); | |
| 688 #endif | |
| 689 | |
| 442 | 690 |
| 771 | 691 /************************************************************************/ |
| 692 /* Functions to handle arguments */ | |
| 693 /************************************************************************/ | |
| 694 | |
| 428 | 695 /* Code for dealing with Lisp access to the Unix command line */ |
| 696 | |
| 697 static Lisp_Object | |
| 2367 | 698 make_arg_list_1 (int argc, Wexttext **argv, int skip_args) |
| 428 | 699 { |
| 700 Lisp_Object result = Qnil; | |
| 701 REGISTER int i; | |
| 702 | |
| 703 for (i = argc - 1; i >= 0; i--) | |
| 704 { | |
| 705 if (i == 0 || i > skip_args) | |
| 706 { | |
| 442 | 707 #ifdef WIN32_NATIVE |
| 428 | 708 if (i == 0) |
| 709 { | |
| 710 /* Do not trust to what crt0 has stuffed into argv[0] */ | |
| 814 | 711 Extbyte *full_exe_path; |
| 442 | 712 Lisp_Object fullpath; |
| 713 | |
| 814 | 714 full_exe_path = mswindows_get_module_file_name (); |
| 715 assert (full_exe_path); | |
| 771 | 716 fullpath = build_tstr_string (full_exe_path); |
| 1726 | 717 xfree (full_exe_path, Extbyte *); |
| 442 | 718 result = Fcons (fullpath, result); |
| 428 | 719 } |
| 720 else | |
| 721 #endif | |
| 2367 | 722 result = Fcons (build_wext_string (argv[i], |
| 723 Qcommand_argument_encoding), | |
| 440 | 724 result); |
| 428 | 725 } |
| 726 } | |
| 727 return result; | |
| 728 } | |
| 729 | |
| 730 Lisp_Object | |
| 2367 | 731 make_arg_list (int argc, Wexttext **argv) |
| 428 | 732 { |
| 733 return make_arg_list_1 (argc, argv, 0); | |
| 734 } | |
| 735 | |
| 736 /* Calling functions are also responsible for calling free_argc_argv | |
| 737 when they are done with the generated list. */ | |
| 738 void | |
| 2367 | 739 make_argc_argv (Lisp_Object argv_list, int *argc, Wexttext ***argv) |
| 428 | 740 { |
| 741 Lisp_Object next; | |
| 742 int n = XINT (Flength (argv_list)); | |
| 743 REGISTER int i; | |
| 2367 | 744 *argv = xnew_array (Wexttext *, n + 1); |
| 428 | 745 |
| 746 for (i = 0, next = argv_list; i < n; i++, next = XCDR (next)) | |
| 747 { | |
| 748 CHECK_STRING (XCAR (next)); | |
| 749 | |
| 2367 | 750 LISP_STRING_TO_EXTERNAL_MALLOC (XCAR (next), (*argv) [i], |
| 751 Qcommand_argument_encoding); | |
| 428 | 752 } |
| 753 (*argv) [n] = 0; | |
| 754 *argc = i; | |
| 755 } | |
| 756 | |
| 757 void | |
| 2367 | 758 free_argc_argv (Wexttext **argv) |
| 428 | 759 { |
| 760 int elt = 0; | |
| 761 | |
| 762 while (argv[elt]) | |
| 763 { | |
| 2367 | 764 xfree (argv[elt], Wexttext *); |
| 428 | 765 elt++; |
| 766 } | |
| 2367 | 767 xfree (argv, Wexttext **); |
| 428 | 768 } |
| 769 | |
| 770 static void | |
| 2367 | 771 init_cmdargs (int argc, Wexttext **argv, int skip_args) |
| 428 | 772 { |
| 773 initial_argv = argv; | |
| 774 initial_argc = argc; | |
| 775 | |
| 776 Vcommand_line_args = make_arg_list_1 (argc, argv, skip_args); | |
| 777 } | |
| 778 | |
| 779 DEFUN ("invocation-name", Finvocation_name, 0, 0, 0, /* | |
| 780 Return the program name that was used to run XEmacs. | |
| 781 Any directory names are omitted. | |
| 782 */ | |
| 783 ()) | |
| 784 { | |
| 785 return Fcopy_sequence (Vinvocation_name); | |
| 786 } | |
| 787 | |
| 788 DEFUN ("invocation-directory", Finvocation_directory, 0, 0, 0, /* | |
| 789 Return the directory name in which the Emacs executable was located. | |
| 790 */ | |
| 791 ()) | |
| 792 { | |
| 793 return Fcopy_sequence (Vinvocation_directory); | |
| 794 } | |
| 795 | |
| 796 | |
| 797 | |
| 776 | 798 /* Test whether the next argument in ARGV matches SSTR or a prefix of LSTR |
| 799 (at least MINLEN characters; if MINLEN is 0, set to size of LSTR). If | |
| 800 so, then if VALPTR is non-null (the argument is supposed to have a | |
| 801 value) store in *VALPTR either the next argument or the portion of this | |
| 802 one after the equal sign. ARGV is read starting at position *SKIPPTR; | |
| 803 this index is advanced by the number of arguments used. | |
| 428 | 804 |
| 805 Too bad we can't just use getopt for all of this, but we don't have | |
| 806 enough information to do it right. */ | |
| 807 | |
| 808 static int | |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
809 argmatch (Wexttext **argv, int argc, const Ascbyte *sstr, const Ascbyte *lstr, |
| 2367 | 810 int minlen, Wexttext **valptr, int *skipptr) |
| 428 | 811 { |
| 2367 | 812 Wexttext *p = NULL; |
| 813 Charcount arglen; | |
| 814 Wexttext *arg; | |
| 428 | 815 |
| 816 /* Don't access argv[argc]; give up in advance. */ | |
| 817 if (argc <= *skipptr + 1) | |
| 818 return 0; | |
| 819 | |
| 820 arg = argv[*skipptr+1]; | |
| 821 if (arg == NULL) | |
| 822 return 0; | |
| 2367 | 823 if (wext_strcmp_ascii (arg, sstr) == 0) |
| 428 | 824 { |
| 825 if (valptr != NULL) | |
| 826 { | |
| 827 *valptr = argv[*skipptr+2]; | |
| 828 *skipptr += 2; | |
| 829 } | |
| 830 else | |
| 831 *skipptr += 1; | |
| 832 return 1; | |
| 833 } | |
| 2367 | 834 arglen = (valptr != NULL && (p = wext_strchr (arg, '=')) != NULL |
| 835 ? p - arg : (Charcount) wext_strlen (arg)); | |
| 776 | 836 if (lstr && !minlen) |
| 837 minlen = strlen (lstr); | |
| 2367 | 838 if (lstr == 0 || arglen < minlen || |
| 839 wext_strncmp_ascii (arg, lstr, arglen) != 0) | |
| 428 | 840 return 0; |
| 841 else if (valptr == NULL) | |
| 842 { | |
| 843 *skipptr += 1; | |
| 844 return 1; | |
| 845 } | |
| 846 else if (p != NULL) | |
| 847 { | |
| 2367 | 848 *valptr = p + 1; |
| 428 | 849 *skipptr += 1; |
| 850 return 1; | |
| 851 } | |
| 2367 | 852 else if (argv[*skipptr + 2] != NULL) |
| 428 | 853 { |
| 2367 | 854 *valptr = argv[*skipptr + 2]; |
| 428 | 855 *skipptr += 2; |
| 856 return 1; | |
| 857 } | |
| 858 else | |
| 859 { | |
| 860 return 0; | |
| 861 } | |
| 862 } | |
| 863 | |
| 1315 | 864 static void |
|
4528
726060ee587c
First draft of g++ 4.3 warning removal patch. Builds. *Needs ChangeLogs.*
Stephen J. Turnbull <stephen@xemacs.org>
parents:
4522
diff
changeset
|
865 check_compatible_window_system (const Ascbyte *must) |
| 1315 | 866 { |
| 867 if (display_use && strcmp (display_use, must)) | |
| 868 fatal ("Incompatible window system type `%s': `%s' already specified", | |
| 869 must, display_use); | |
| 870 display_use = must; | |
| 871 } | |
| 872 | |
| 771 | 873 |
| 874 /************************************************************************/ | |
| 875 /* main and friends: XEmacs startup */ | |
| 876 /************************************************************************/ | |
| 877 | |
| 428 | 878 /* Make stack traces always identify version + configuration */ |
| 879 #define main_1 STACK_TRACE_EYE_CATCHER | |
| 880 | |
| 881 /* This function is not static, so that the compiler is less likely to | |
| 446 | 882 inline it, which would make it not show up in stack traces. |
| 883 | |
| 884 The restart argument is a flag that indicates that main_1 is now | |
| 771 | 885 being called for the second time in this invocation of xemacs; this |
| 886 happens as a result of using `run-temacs' in the command line, when | |
| 887 invoking a bare (without dumped data) XEmacs (i.e. `temacs' with | |
| 888 the conventional dumper or `xemacs -nd' with the pdumper). See | |
| 446 | 889 Frun_emacs_from_temacs(). |
| 890 */ | |
| 2367 | 891 DECLARE_DOESNT_RETURN (main_1 (int, Wexttext **, Wexttext **, int)); |
| 428 | 892 DOESNT_RETURN |
| 2367 | 893 main_1 (int argc, Wexttext **argv, Wexttext **UNUSED (envp), int restart) |
| 428 | 894 { |
| 2367 | 895 Rawbyte stack_bottom_variable; |
| 428 | 896 int skip_args = 0; |
| 897 Lisp_Object load_me; | |
| 898 #ifdef NeXT | |
| 899 extern int malloc_cookie; | |
| 900 #endif | |
| 901 | |
| 902 #if (!defined (SYSTEM_MALLOC) && !defined (HAVE_LIBMCHECK) \ | |
| 903 && !defined (DOUG_LEA_MALLOC)) | |
| 904 /* Make sure that any libraries we link against haven't installed a | |
| 905 hook for a gmalloc of a potentially incompatible version. */ | |
| 906 /* If we're using libmcheck, the hooks have already been initialized, */ | |
| 907 /* don't touch them. -slb */ | |
| 908 __malloc_hook = NULL; | |
| 909 __realloc_hook = NULL; | |
| 910 __free_hook = NULL; | |
| 911 #endif /* not SYSTEM_MALLOC or HAVE_LIBMCHECK or DOUG_LEA_MALLOC */ | |
| 912 | |
| 913 noninteractive = 0; | |
| 3360 | 914 display_use = NULL; |
| 2367 | 915 inhibit_non_essential_conversion_operations = 1; |
| 428 | 916 |
| 3263 | 917 #ifdef NEW_GC |
| 2720 | 918 #ifndef PDUMP |
| 919 if (!initialized) | |
| 920 #endif | |
| 921 { | |
| 2723 | 922 if (!restart) |
| 923 { | |
| 924 init_mc_allocator (); | |
| 2994 | 925 #ifdef ALLOC_TYPE_STATS |
| 2723 | 926 init_lrecord_stats (); |
| 2994 | 927 #endif /* ALLOC_TYPE_STATS */ |
| 2723 | 928 } |
| 2720 | 929 } |
| 3263 | 930 #endif /* NEW_GC */ |
| 2720 | 931 |
| 428 | 932 #ifdef NeXT |
| 933 /* 19-Jun-1995 -baw | |
| 934 * NeXT secret magic, ripped from Emacs-for-NS by Carl Edman | |
| 935 * <cedman@princeton.edu>. Note that even Carl doesn't know what this | |
| 776 | 936 * does; it was provided by NeXT, and it presumably makes NS's mallocator |
| 428 | 937 * work with dumping. But malloc_jumpstart() and malloc_freezedry() in |
| 938 * unexnext.c are both completely undocumented, even in NS header files! | |
| 939 * But hey, it solves all NS related memory problems, so who's | |
| 940 * complaining? */ | |
| 941 if (initialized && malloc_jumpstart (malloc_cookie) != 0) | |
| 442 | 942 stderr_out ("malloc jumpstart failed!\n"); |
| 428 | 943 #endif /* NeXT */ |
| 944 | |
| 945 /* | |
| 946 #if defined (GNU_MALLOC) && \ | |
| 947 defined (ERROR_CHECK_MALLOC) && \ | |
| 948 !defined (HAVE_LIBMCHECK) | |
| 949 */ | |
| 1303 | 950 #if defined (LOSING_GCC_DESTRUCTOR_FREE_BUG) |
| 428 | 951 /* Prior to XEmacs 21, this was `#if 0'ed out. */ |
| 952 /* I'm enabling this because it is the only reliable way I've found to */ | |
| 1303 | 953 /* prevent a very annoying problem where GCC will attempt to free (3) */ |
| 428 | 954 /* memory at exit() and cause a coredump. */ |
| 955 init_free_hook (); | |
| 956 #endif | |
| 957 | |
|
4448
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
958 #define SHEBANG_PROGNAME_LENGTH \ |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
959 (int)((sizeof (WEXTSTRING (SHEBANG_PROGNAME)) - sizeof (WEXTSTRING ("")))) |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
960 #define SHEBANG_EXE_PROGNAME_LENGTH \ |
|
4458
d9b9b5f90386
Provide SHEBANG_PROGNAME on Win32; correct a bug with it and string concat'ing
Aidan Kehoe <kehoea@parhasard.net>
parents:
4450
diff
changeset
|
961 (int)(sizeof (WEXTSTRING (SHEBANG_PROGNAME) WEXTSTRING(".exe")) \ |
|
4448
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
962 - sizeof (WEXTSTRING (""))) |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
963 |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
964 { |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
965 int progname_len = wext_strlen (argv[0]); |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
966 if (progname_len >= SHEBANG_PROGNAME_LENGTH) |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
967 { |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
968 if (!wext_strcmp_ascii (argv[0] + |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
969 (progname_len - SHEBANG_PROGNAME_LENGTH), |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
970 SHEBANG_PROGNAME) |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
971 /* Allow trailing .exe. Don't check it, it could also be |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
972 .com. */ |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
973 || (progname_len >= SHEBANG_EXE_PROGNAME_LENGTH && |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
974 !wext_strncmp_ascii |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
975 (argv[0] + (progname_len - SHEBANG_EXE_PROGNAME_LENGTH), |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
976 SHEBANG_PROGNAME, |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
977 SHEBANG_PROGNAME_LENGTH))) |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
978 { |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
979 Wexttext **newarr = alloca_array (Wexttext *, argc + 2); |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
980 int j; |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
981 |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
982 newarr[0] = argv[0]; |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
983 newarr[1] = WEXTSTRING ("--script"); |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
984 for (j = 1; j < argc; ++j) |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
985 { |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
986 newarr[j + 1] = argv[j]; |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
987 } |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
988 argv = newarr; |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
989 argc++; |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
990 } |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
991 } |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
992 } |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
993 |
| 428 | 994 sort_args (argc, argv); |
| 995 | |
| 2367 | 996 #if 0 /* defined (_SCO_DS) |
| 997 #### Turn this off, we already have another SCO_DS hack in main(). | |
| 998 */ | |
| 428 | 999 environ = envp; |
| 1000 #endif | |
| 1001 | |
| 1002 /* Record (approximately) where the stack begins. */ | |
| 1003 stack_bottom = &stack_bottom_variable; | |
| 1004 | |
| 1005 #ifdef USG_SHARED_LIBRARIES | |
| 1006 if (bss_end) | |
| 1007 brk ((void *) bss_end); | |
| 1008 #endif | |
| 1009 | |
| 1010 clearerr (stdin); | |
| 1011 | |
| 1012 #if defined (HAVE_MMAP) && defined (REL_ALLOC) | |
| 1013 /* ralloc can only be used if using the GNU memory allocator. */ | |
| 1014 init_ralloc (); | |
| 1303 | 1015 #elif defined (REL_ALLOC) && !defined (DOUG_LEA_MALLOC) |
| 428 | 1016 if (initialized) |
| 1303 | 1017 init_ralloc (); |
| 428 | 1018 #endif |
| 1019 | |
| 1020 #ifdef HAVE_SOCKS | |
| 1021 if (initialized) | |
| 1022 SOCKSinit (argv[0]); | |
| 1023 #endif /* HAVE_SOCKS */ | |
| 1024 | |
| 1025 #ifndef SYSTEM_MALLOC | |
| 1026 if (!initialized) | |
| 1027 /* Arrange to get warning messages as memory fills up. */ | |
| 1028 memory_warnings (0, malloc_warning); | |
| 1029 #endif /* not SYSTEM_MALLOC */ | |
| 1030 | |
| 1031 #ifdef SET_EMACS_PRIORITY | |
| 1032 if (emacs_priority != 0) | |
| 1033 nice (-emacs_priority); | |
| 1034 setuid (getuid ()); | |
| 1035 #endif /* SET_EMACS_PRIORITY */ | |
| 1036 | |
| 1037 #ifdef EXTRA_INITIALIZE | |
| 1038 EXTRA_INITIALIZE; | |
| 1039 #endif | |
| 1040 | |
| 776 | 1041 /* NOTE NOTE NOTE: Keep the following args in sync with the big list of |
| 1042 arguments below in standard_args[], with the help text in startup.el, | |
| 1043 and with the list of non-clobbered variables near where pdump_load() | |
| 1044 is called! */ | |
| 854 | 1045 |
| 776 | 1046 /* Handle the -sd/--show-dump-id switch, which means show the hex dump_id |
| 1047 and quit */ | |
| 1048 if (argmatch (argv, argc, "-sd", "--show-dump-id", 0, NULL, &skip_args)) | |
| 442 | 1049 { |
| 1050 #ifdef PDUMP | |
| 1051 printf ("%08x\n", dump_id); | |
| 1052 #else | |
| 446 | 1053 printf ("Portable dumper not configured; -sd just forces exit.\n"); |
| 442 | 1054 #endif |
| 1055 exit (0); | |
| 1056 } | |
| 854 | 1057 |
| 2015 | 1058 /* Handle the -si/--show-inline-info switch, which means show the |
| 1059 alignment and max size of the inline data and quit */ | |
| 1060 if (argmatch (argv, argc, "-si", "--show-inline-info", 0, NULL, &skip_args)) | |
| 1061 { | |
| 2720 | 1062 #if defined (PDUMP) && defined (DUMP_IN_EXEC) && !defined (WIN32_NATIVE) |
| 3094 | 1063 /* #### We really should check for sizeof (size_t) > sizeof (long) */ |
| 1064 printf ("%lu %lu\n", (unsigned long) dumped_data_max_size (), | |
| 1065 (unsigned long) dumped_data_align_offset ()); | |
| 1066 | |
| 2015 | 1067 #else |
| 2720 | 1068 printf ("Portable dumper not configured for dumping into executable or windows native; -si just forces exit.\n"); |
| 2015 | 1069 #endif |
| 1070 exit (0); | |
| 1071 } | |
| 1072 | |
| 776 | 1073 /* Handle the --no-dump-file/-nd switch, which means don't load the dump |
| 1074 file (ignored when not using pdump) */ | |
| 1075 if (argmatch (argv, argc, "-nd", "--no-dump-file", 0, NULL, &skip_args)) | |
| 1076 nodumpfile = 1; | |
| 442 | 1077 |
| 428 | 1078 /* Handle the -batch switch, which means don't do interactive display. */ |
| 776 | 1079 if (argmatch (argv, argc, "-batch", "--batch", 0, NULL, &skip_args)) |
| 428 | 1080 { |
| 1081 #if 0 /* I don't think this is correct. */ | |
| 1082 inhibit_autoloads = 1; | |
| 1083 #endif | |
| 1084 noninteractive = 1; | |
| 1085 } | |
| 1086 | |
|
4448
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1087 { |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1088 int count_before = skip_args; |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1089 /* Handle the -script switch, which implies batch and vanilla. The -l |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1090 part of its functionality is implemented in Lisp. */ |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1091 if (argmatch (argv, argc, "-script", "--script", 0, NULL, |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1092 &skip_args)) |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1093 { |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1094 noninteractive = 1; |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1095 vanilla_inhibiting = 1; |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1096 } |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1097 |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1098 /* Don't actually discard this argument. */ |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1099 skip_args = count_before; |
|
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
1100 } |
| 771 | 1101 #ifdef WIN32_NATIVE |
| 826 | 1102 { |
| 1103 /* Since we aren't a console application, we can't easily be terminated | |
| 1104 using ^C. (We aren't a console application to avoid Windows from | |
| 1105 automatically and unwantedly creating a console window for us. If | |
| 1106 only the Windows designers had some sense in them and didn't create | |
| 1107 this artificial console/non-console distinction!) Therefore, we set | |
| 1108 up a communication path with i.exe so that when a ^C is sent to it | |
| 1109 (using GenerateConsoleCtrlEvent), it in turn signals us to commit | |
| 1110 suicide. (This is cleaner than using TerminateProcess()). This | |
| 1111 makes (e.g.) the "Stop Build" command from VC++ correctly terminate | |
| 1112 XEmacs. */ | |
| 854 | 1113 |
| 2367 | 1114 Wexttext *heventstr; |
| 826 | 1115 if (argmatch (argv, argc, "-mswindows-termination-handle", 0, 0, |
| 1116 &heventstr, &skip_args)) | |
| 1117 { | |
| 2367 | 1118 HANDLE hevent = (HANDLE) wext_atol (heventstr); |
| 826 | 1119 DWORD unused; |
| 1120 HANDLE h_thread = CreateThread (NULL, 0, wait_for_termination_signal, | |
| 1121 (void *) hevent, 0, &unused); | |
| 1122 CloseHandle (h_thread); | |
| 1123 } | |
| 1124 } | |
| 1125 | |
| 771 | 1126 /* Handle the -nuni switch, which forces XEmacs to use the ANSI |
| 1127 versions of Unicode-split API's even on Windows NT, which has | |
| 1128 full Unicode support. This helps flush out problems in the code | |
| 1129 we've written to convert between ANSI and Unicode. */ | |
| 776 | 1130 if (argmatch (argv, argc, "-nuni", "--no-unicode-lib-calls", 0, NULL, |
| 771 | 1131 &skip_args)) |
| 1132 no_mswin_unicode_lib_calls = 1; | |
| 1133 #endif /* WIN32_NATIVE */ | |
| 1134 | |
| 428 | 1135 if (argmatch (argv, argc, "-debug-paths", "--debug-paths", |
| 776 | 1136 0, NULL, &skip_args)) |
| 1137 debug_paths = 1; | |
| 1138 | |
| 1139 /* Handle (maybe partially) some inhibiting flags. Packages are searched | |
| 1140 prior to the rest of the command line being parsed in startup.el. */ | |
| 1141 | |
| 1142 if (argmatch (argv, argc, "-no-packages", "--no-packages", | |
| 1143 0, NULL, &skip_args)) | |
| 1144 { | |
| 1145 inhibit_all_packages = 1; | |
| 1146 inhibit_early_packages = 1; | |
| 1147 vanilla_inhibiting = 1; | |
| 1148 } | |
| 1149 | |
| 428 | 1150 if (argmatch (argv, argc, "-no-early-packages", "--no-early-packages", |
| 776 | 1151 0, NULL, &skip_args)) |
| 1152 inhibit_early_packages = 1; | |
| 1153 | |
| 1154 #ifdef HAVE_SHLIB | |
| 1155 if (argmatch (argv, argc, "-no-site-modules", "--no-site-modules", | |
| 1156 0, NULL, &skip_args)) | |
| 1157 #endif | |
| 1158 inhibit_site_modules = 1; | |
| 854 | 1159 |
| 776 | 1160 if (argmatch (argv, argc, "-vanilla", "--vanilla", |
| 1161 0, NULL, &skip_args)) | |
| 428 | 1162 { |
| 1163 inhibit_early_packages = 1; | |
| 776 | 1164 vanilla_inhibiting = 1; |
| 428 | 1165 } |
| 1166 | |
| 1167 if (argmatch (argv, argc, "-no-autoloads", "--no-autoloads", | |
| 776 | 1168 0, NULL, &skip_args)) |
| 428 | 1169 { |
| 1170 inhibit_autoloads = 1; | |
| 776 | 1171 inhibit_early_packages = 1; |
| 1172 vanilla_inhibiting = 1; | |
| 428 | 1173 } |
| 1174 | |
| 1175 /* Partially handle the -version and -help switches: they imply -batch, | |
| 1176 but are not removed from the list. */ | |
| 1177 if (argmatch (argv, argc, "-help", "--help", 3, NULL, &skip_args)) | |
| 1178 noninteractive = 1, skip_args--; | |
| 1179 | |
| 1180 if (argmatch (argv, argc, "-version", "--version", 3, NULL, &skip_args) || | |
| 1181 argmatch (argv, argc, "-V", 0, 2, NULL, &skip_args)) | |
| 1182 noninteractive = 1, skip_args--; | |
| 1183 | |
| 1184 /* Now, figure out which type of console is our first console. */ | |
| 1185 | |
| 1186 if (noninteractive) | |
| 1187 display_use = "stream"; | |
| 1315 | 1188 |
| 1189 if (argmatch (argv, argc, "-nw", "--no-windows", 0, NULL, &skip_args) || | |
| 1190 argmatch (argv, argc, "-tty", "--use-tty", 0, NULL, &skip_args)) | |
| 1191 { | |
| 1192 check_compatible_window_system ("tty"); | |
| 428 | 1193 #ifndef HAVE_TTY |
| 1315 | 1194 fatal ("Sorry, this XEmacs was not compiled with TTY support"); |
| 1195 #endif | |
| 1196 } | |
| 1197 | |
| 1198 if (argmatch (argv, argc, "-x", "--use-x", 0, NULL, &skip_args)) | |
| 1199 { | |
| 1200 check_compatible_window_system ("x"); | |
| 1201 #ifndef HAVE_X_WINDOWS | |
| 1202 fatal ("Sorry, this XEmacs was not compiled with X support"); | |
| 1203 #endif | |
| 1204 } | |
| 1205 | |
| 1206 if (argmatch (argv, argc, "-gtk", "--use-gtk", 0, NULL, &skip_args) || | |
| 1207 argmatch (argv, argc, "-gnome", "--use-gnome", 0, NULL, &skip_args)) | |
| 1208 { | |
| 1209 check_compatible_window_system ("gtk"); | |
| 1210 #ifndef HAVE_GTK | |
| 1211 fatal ("Sorry, this XEmacs was not compiled with GTK support"); | |
| 1212 #endif | |
| 1213 } | |
| 1214 | |
| 1215 if (argmatch (argv, argc, "-msw", "--use-ms-windows", 0, NULL, &skip_args)) | |
| 1216 { | |
| 1217 check_compatible_window_system ("mswindows"); | |
| 1218 #ifndef HAVE_MS_WINDOWS | |
| 1219 fatal ("Sorry, this XEmacs was not compiled with MS Windows support"); | |
| 1220 #endif | |
| 1221 } | |
| 1222 | |
| 1223 /* Handle other switches implying particular window systems: */ | |
| 1224 | |
| 1225 /* Handle the -t switch, which specifies filename to use as terminal */ | |
| 1226 { | |
| 2367 | 1227 Wexttext *term; |
| 1315 | 1228 if (argmatch (argv, argc, "-t", "--terminal", 0, &term, &skip_args)) |
| 1229 { | |
| 2367 | 1230 int fd; |
| 1231 | |
| 1315 | 1232 check_compatible_window_system ("tty"); |
| 1233 #ifndef HAVE_TTY | |
| 1234 fatal ("Sorry, this XEmacs was not compiled with TTY support"); | |
| 1235 #endif | |
| 1236 | |
| 1237 retry_close (0); | |
| 1238 retry_close (1); | |
| 2367 | 1239 |
| 1240 fd = wext_retry_open (term, O_RDWR | OPEN_BINARY, 2); | |
| 1241 /* Conversions are not possible yet, and printing will be in | |
| 1242 external format, so strerror() and ttyname() are OK. */ | |
| 1243 if (fd < 0) | |
| 1244 fatal ("%s: %s", WEXTTEXT_TO_8_BIT (term), strerror (errno)); | |
| 1315 | 1245 dup (0); |
| 1246 if (! isatty (0)) | |
| 2367 | 1247 fatal ("%s: not a tty", WEXTTEXT_TO_8_BIT (term)); |
| 1315 | 1248 |
| 1249 #if 0 | |
| 1250 stderr_out ("Using %s", ttyname (0)); | |
| 1251 #endif | |
| 2367 | 1252 stderr_out ("Using %s", WEXTTEXT_TO_8_BIT (term)); |
| 1315 | 1253 } |
| 1254 } | |
| 1255 | |
| 428 | 1256 /* Stupid kludge to catch command-line display spec. We can't |
| 1257 handle this argument entirely in window-system-dependent code | |
| 1258 because we don't even know which window-system-dependent code | |
| 1259 to run until we've recognized this argument. */ | |
| 1315 | 1260 { |
| 428 | 1261 #ifdef HAVE_X_WINDOWS |
| 2367 | 1262 Wexttext *dpy = 0; |
| 1315 | 1263 int count_before = skip_args; |
| 1264 | |
| 1265 if (argmatch (argv, argc, "-d", "--display", 3, &dpy, &skip_args) || | |
| 1266 argmatch (argv, argc, "-display", 0, 3, &dpy, &skip_args)) | |
| 1267 { | |
| 1268 check_compatible_window_system ("x"); | |
| 1269 display_arg = 1; | |
| 1270 } | |
| 428 | 1271 /* If we have the form --display=NAME, |
| 1272 convert it into -d name. | |
| 1273 This requires inserting a new element into argv. */ | |
| 1274 if (dpy != 0 && skip_args - count_before == 1) | |
| 1275 { | |
| 2994 | 1276 Wexttext **new_ = xnew_array (Wexttext *, argc + 2); |
| 428 | 1277 int j; |
| 1278 | |
| 1279 for (j = 0; j < count_before + 1; j++) | |
| 2994 | 1280 new_[j] = argv[j]; |
| 1281 new_[count_before + 1] = WEXTSTRING ("-d"); | |
| 1282 new_[count_before + 2] = dpy; | |
| 428 | 1283 for (j = count_before + 2; j <argc; j++) |
| 2994 | 1284 new_[j + 1] = argv[j]; |
| 1285 argv = new_; | |
| 428 | 1286 argc++; |
| 1287 } | |
| 1288 /* Change --display to -d, when its arg is separate. */ | |
| 1289 else if (dpy != 0 && skip_args > count_before | |
| 1290 && argv[count_before + 1][1] == '-') | |
| 2367 | 1291 argv[count_before + 1] = WEXTSTRING ("-d"); |
| 428 | 1292 |
| 1293 /* Don't actually discard this arg. */ | |
| 1294 skip_args = count_before; | |
| 1315 | 1295 #endif /* HAVE_X_WINDOWS */ |
| 1296 } | |
| 1297 | |
| 1298 /* If no switch telling us which window system to use, try other | |
| 1299 possibilities: */ | |
| 1300 | |
| 1301 #if defined (HAVE_X_WINDOWS) || defined (HAVE_GTK) | |
| 1302 if (!display_use) | |
| 1303 { | |
| 2367 | 1304 Wexttext *dpy; |
| 1315 | 1305 /* If there is a non-empty environment var DISPLAY, assume X or GTK, |
| 1306 but don't set `display_arg', which is only to be set if the | |
| 1307 display was specified on the command line. */ | |
| 2367 | 1308 if ((dpy = wext_getenv (WEXTSTRING ("DISPLAY"))) && dpy[0]) |
| 1315 | 1309 #ifdef HAVE_X_WINDOWS |
| 1310 /* #### Who gets precedence? X or GTK? For the moment, GTK support is | |
| 1311 unstable so use X. Maybe eventually we will switch this. */ | |
| 428 | 1312 display_use = "x"; |
| 1315 | 1313 #else |
| 1314 display_use = "gtk"; | |
| 1315 #endif | |
| 1316 } | |
| 1317 #endif /* defined (HAVE_X_WINDOWS) || defined (HAVE_GTK) */ | |
| 1318 | |
| 428 | 1319 #ifdef HAVE_MS_WINDOWS |
| 1315 | 1320 if (!display_use) |
| 1321 display_use = "mswindows"; | |
| 428 | 1322 #endif /* HAVE_MS_WINDOWS */ |
| 1315 | 1323 |
| 1324 #ifdef HAVE_TTY | |
| 1325 if (!display_use) | |
| 1326 display_use = "tty"; | |
| 1327 #endif /* HAVE_MS_WINDOWS */ | |
| 1328 | |
| 1329 if (!display_use) | |
| 1330 fatal ("No window systems and no TTY's in this XEmacs: Must specify " | |
| 1331 "-batch"); | |
| 428 | 1332 |
| 1333 noninteractive1 = noninteractive; | |
| 1334 | |
| 1335 /****** Now initialize everything *******/ | |
| 1336 | |
| 1204 | 1337 /* NOTE NOTE NOTE: |
| 1338 | |
| 1339 In the code below, there are three different states we are concerned | |
| 1340 about: | |
| 1341 | |
| 1342 "raw-temacs" == No dumped Lisp data present. `temacs', or (with pdump) | |
| 1343 `xemacs -nd'. | |
| 1344 | |
| 1345 "run-temacs" == We are restarting. run-emacs-from-temacs is called, | |
| 1346 aka `run-temacs' on the command line. | |
| 1347 | |
| 1348 "post-dump" == We are running an unexec()ed XEmacs, or we have loaded | |
| 1349 dump data using pdump_load(). | |
| 1350 | |
| 1351 initialized==0 => raw-temacs | |
| 1352 initialized!=0 && restart!=0 => run-temacs | |
| 1353 initialized!=0 && restart==0 => post-dump | |
| 1354 | |
| 1355 When post-pdump_load(), we need to reinitialize various structures. | |
| 1356 This case is noted in the code below by | |
| 1357 | |
| 1358 initialized + | |
| 1359 !restart + | |
| 1360 ifdef PDUMP. | |
| 1361 | |
| 1362 In the comments below, "dump time" or "dumping" == raw-temacs. | |
| 1363 "run time" == run-temacs or post-dump. | |
| 1364 */ | |
| 1365 | |
| 428 | 1366 /* First, do really basic environment initialization -- catching signals |
| 1367 and the like. These functions have no dependence on any part of | |
| 1368 the Lisp engine and need to be done both at dump time and at run time. */ | |
| 1369 | |
| 1370 init_signals_very_early (); | |
| 3092 | 1371 #ifdef NEW_GC |
| 1372 vdb_install_signal_handler (); | |
| 3263 | 1373 #endif /* NEW_GC */ |
| 428 | 1374 init_data_very_early (); /* Catch math errors. */ |
| 1375 init_floatfns_very_early (); /* Catch floating-point math errors. */ | |
| 1376 init_process_times_very_early (); /* Initialize our process timers. | |
| 1377 As early as possible, of course, | |
| 1378 so we can be fairly accurate. */ | |
| 771 | 1379 |
| 657 | 1380 #ifdef HAVE_MS_WINDOWS |
| 2367 | 1381 /* Depends on XEUNICODE_P */ |
| 771 | 1382 init_mswindows_dde_very_early (); /* DDE needs to be initialized early so |
| 1383 that the client doesn't give up | |
| 1384 waiting. */ | |
| 657 | 1385 #endif |
| 428 | 1386 |
| 1387 /* Now initialize the Lisp engine and the like. Done only during | |
| 1388 dumping. No dependence on anything that may be in the user's | |
| 1389 environment when the dumped XEmacs is run. | |
| 1390 | |
| 1391 We try to do things in an order that minimizes the non-obvious | |
| 1392 dependencies between functions. */ | |
| 1393 | |
| 1330 | 1394 /* purify_flag is set to indicate we are dumping (its name refers to |
| 1395 purespace, which no longer exists and was a way of marking some | |
| 1396 areas read-only so they could be shared among many processes). | |
| 1397 | |
| 1398 loadup.el will set to nil at end. */ | |
| 428 | 1399 |
| 1400 purify_flag = 0; | |
| 1401 #ifdef PDUMP | |
| 1204 | 1402 in_pdump = 0; |
| 428 | 1403 if (restart) |
| 1404 initialized = 1; | |
| 771 | 1405 else if (nodumpfile) |
| 1406 { | |
| 1407 initialized = 0; | |
| 442 | 1408 purify_flag = 1; |
| 771 | 1409 } |
| 1410 else | |
| 1411 { | |
| 1412 | |
| 1413 /* Keep command options from getting stomped. | |
| 1414 | |
| 1415 Some LISP-visible options are changed by XEmacs _after_ the data is | |
| 1416 dumped in building a --pdump XEmacs, but _before_ it is restored in | |
| 1417 normal operation. Thus the restored values overwrite the values | |
| 1418 XEmacs is getting at run-time. Such variables must be saved here, | |
| 1419 and restored after loading the dumped data. | |
| 1420 | |
| 776 | 1421 (Remember: Only LISP-visible options that are set up to this point |
| 1422 need to be listed here.) | |
| 771 | 1423 */ |
| 1424 | |
| 1425 /* noninteractive1 is saved in noninteractive, which isn't | |
| 1426 LISP-visible */ | |
| 1427 int inhibit_early_packages_save = inhibit_early_packages; | |
| 1428 int inhibit_autoloads_save = inhibit_autoloads; | |
| 776 | 1429 int inhibit_all_packages_save = inhibit_all_packages; |
| 1430 int vanilla_inhibiting_save = vanilla_inhibiting; | |
| 771 | 1431 int debug_paths_save = debug_paths; |
| 776 | 1432 int inhibit_site_lisp_save = inhibit_site_lisp; |
| 771 | 1433 int inhibit_site_modules_save = inhibit_site_modules; |
| 1434 | |
| 1435 initialized = pdump_load (argv[0]); | |
| 1436 | |
| 1437 /* Now unstomp everything */ | |
| 1438 noninteractive1 = noninteractive; | |
| 1439 inhibit_early_packages = inhibit_early_packages_save; | |
| 1440 inhibit_autoloads = inhibit_autoloads_save; | |
| 776 | 1441 inhibit_all_packages = inhibit_all_packages_save; |
| 1442 vanilla_inhibiting = vanilla_inhibiting_save; | |
| 771 | 1443 debug_paths = debug_paths_save; |
| 776 | 1444 inhibit_site_lisp = inhibit_site_lisp_save; |
| 771 | 1445 inhibit_site_modules = inhibit_site_modules_save; |
| 1446 | |
| 1447 if (initialized) | |
| 3466 | 1448 run_temacs_argc = -1; |
| 771 | 1449 else |
| 1450 purify_flag = 1; | |
| 1451 } | |
| 2367 | 1452 #else /* not PDUMP */ |
| 428 | 1453 if (!initialized) |
| 1454 purify_flag = 1; | |
| 1455 #endif | |
| 1456 | |
| 1204 | 1457 init_alloc_early (); |
| 1458 | |
| 3092 | 1459 init_gc_early (); |
| 1460 | |
| 428 | 1461 if (!initialized) |
| 1462 { | |
| 1463 /* Initialize things so that new Lisp objects | |
| 1464 can be created and objects can be staticpro'd. | |
| 1465 Must be basically the very first thing done | |
| 1466 because pretty much all of the initialization | |
| 1467 routines below create new objects. */ | |
| 1468 init_alloc_once_early (); | |
| 1469 | |
| 3092 | 1470 init_gc_once_early (); |
| 1471 | |
| 428 | 1472 /* Initialize Qnil, Qt, Qunbound, and the |
| 1473 obarray. After this, symbols can be | |
| 442 | 1474 interned. This depends on init_alloc_once_early(). */ |
| 428 | 1475 init_symbols_once_early (); |
| 1476 | |
| 1477 /* Declare the basic symbols pertaining to errors, | |
| 442 | 1478 So that DEFERROR*() can be called. */ |
| 428 | 1479 init_errors_once_early (); |
| 1480 | |
| 1481 /* Make sure that opaque pointers can be created. */ | |
| 1482 init_opaque_once_early (); | |
| 1483 | |
| 771 | 1484 /* Make sure that hash tables can be created. */ |
| 1485 init_elhash_once_early (); | |
| 1486 | |
| 1487 /* Make sure that eistrings can be created. */ | |
| 1488 init_eistring_once_early (); | |
| 1204 | 1489 |
| 428 | 1490 /* Now declare all the symbols and define all the Lisp primitives. |
| 1491 | |
| 1492 The *only* thing that the syms_of_*() functions are allowed to do | |
| 442 | 1493 is call one of the following: |
| 1494 | |
| 1495 INIT_LRECORD_IMPLEMENTATION() | |
| 1496 defsymbol(), DEFSYMBOL(), or DEFSYMBOL_MULTIWORD_PREDICATE() | |
| 428 | 1497 defsubr() (i.e. DEFSUBR) |
| 442 | 1498 deferror(), DEFERROR(), or DEFERROR_STANDARD() |
| 1499 defkeyword() or DEFKEYWORD() | |
| 563 | 1500 Fput() |
| 428 | 1501 |
| 1502 Order does not matter in these functions. | |
| 1503 */ | |
| 1504 | |
| 1505 syms_of_abbrev (); | |
| 1506 syms_of_alloc (); | |
| 3263 | 1507 #ifdef NEW_GC |
| 2720 | 1508 syms_of_mc_alloc (); |
| 3263 | 1509 #endif /* NEW_GC */ |
| 3092 | 1510 syms_of_gc (); |
| 1511 #ifdef NEW_GC | |
| 1512 syms_of_vdb (); | |
| 1513 #endif /* NEW_GC */ | |
| 428 | 1514 syms_of_buffer (); |
| 1515 syms_of_bytecode (); | |
| 1516 syms_of_callint (); | |
| 1517 syms_of_casefiddle (); | |
| 1518 syms_of_casetab (); | |
| 1519 syms_of_chartab (); | |
| 1520 syms_of_cmdloop (); | |
| 1521 syms_of_cmds (); | |
| 1522 syms_of_console (); | |
| 1523 syms_of_data (); | |
| 1524 #ifdef DEBUG_XEMACS | |
| 1525 syms_of_debug (); | |
| 440 | 1526 syms_of_tests (); |
| 428 | 1527 #endif /* DEBUG_XEMACS */ |
| 1528 syms_of_device (); | |
| 1529 #ifdef HAVE_DIALOGS | |
| 1530 syms_of_dialog (); | |
| 1531 #endif | |
| 1532 syms_of_dired (); | |
| 1533 syms_of_doc (); | |
| 1534 syms_of_editfns (); | |
| 1535 syms_of_elhash (); | |
| 1536 syms_of_emacs (); | |
| 1537 syms_of_eval (); | |
| 1538 #ifdef HAVE_X_WINDOWS | |
| 1539 syms_of_event_Xt (); | |
| 1540 #endif | |
| 462 | 1541 #ifdef HAVE_GTK |
| 1542 syms_of_event_gtk (); | |
| 1543 #endif | |
| 428 | 1544 #ifdef HAVE_DRAGNDROP |
| 1545 syms_of_dragdrop (); | |
| 1546 #endif | |
| 1547 syms_of_event_stream (); | |
| 1548 syms_of_events (); | |
| 1549 syms_of_extents (); | |
| 1550 syms_of_faces (); | |
| 1551 syms_of_fileio (); | |
| 1552 #ifdef CLASH_DETECTION | |
| 1553 syms_of_filelock (); | |
| 1554 #endif /* CLASH_DETECTION */ | |
| 1555 syms_of_floatfns (); | |
| 1556 syms_of_fns (); | |
| 826 | 1557 #ifdef USE_C_FONT_LOCK |
| 428 | 1558 syms_of_font_lock (); |
| 826 | 1559 #endif /* USE_C_FONT_LOCK */ |
| 428 | 1560 syms_of_frame (); |
| 1561 syms_of_general (); | |
| 1562 syms_of_glyphs (); | |
| 1563 syms_of_glyphs_eimage (); | |
| 563 | 1564 syms_of_glyphs_shared (); |
| 428 | 1565 syms_of_glyphs_widget (); |
| 1566 syms_of_gui (); | |
| 1567 syms_of_gutter (); | |
| 1568 syms_of_indent (); | |
| 1569 syms_of_intl (); | |
| 1570 syms_of_keymap (); | |
| 1571 syms_of_lread (); | |
| 1572 syms_of_macros (); | |
| 1573 syms_of_marker (); | |
| 1574 syms_of_md5 (); | |
| 1575 #ifdef HAVE_DATABASE | |
| 1576 syms_of_database (); | |
| 1577 #endif | |
| 1578 #ifdef HAVE_MENUBARS | |
| 1579 syms_of_menubar (); | |
| 1580 #endif | |
| 1581 syms_of_minibuf (); | |
| 1582 #ifdef HAVE_SHLIB | |
| 1583 syms_of_module (); | |
| 1584 #endif | |
| 1983 | 1585 #ifdef WITH_NUMBER_TYPES |
| 1586 syms_of_number (); | |
| 1587 #endif | |
| 428 | 1588 syms_of_objects (); |
| 1589 syms_of_print (); | |
| 1590 #if !defined (NO_SUBPROCESSES) | |
| 1591 syms_of_process (); | |
| 1592 #ifdef HAVE_WIN32_PROCESSES | |
| 1593 syms_of_process_nt (); | |
| 1594 #endif | |
| 1595 #endif | |
| 1596 syms_of_profile (); | |
| 1303 | 1597 #if defined (HAVE_MMAP) && defined (REL_ALLOC) && !defined (DOUG_LEA_MALLOC) |
| 428 | 1598 syms_of_ralloc (); |
| 1599 #endif /* HAVE_MMAP && REL_ALLOC */ | |
| 1600 syms_of_rangetab (); | |
| 1601 syms_of_redisplay (); | |
| 1602 syms_of_search (); | |
| 1603 syms_of_select (); | |
| 1604 syms_of_signal (); | |
| 1605 syms_of_sound (); | |
| 1606 syms_of_specifier (); | |
| 1607 syms_of_symbols (); | |
| 1608 syms_of_syntax (); | |
| 1609 #ifdef HAVE_SCROLLBARS | |
| 1610 syms_of_scrollbar (); | |
| 1611 #endif | |
| 771 | 1612 syms_of_text (); |
| 428 | 1613 #ifdef HAVE_TOOLBARS |
| 1614 syms_of_toolbar (); | |
| 1615 #endif | |
| 1616 syms_of_undo (); | |
| 1617 syms_of_widget (); | |
| 1618 syms_of_window (); | |
| 1619 | |
| 1620 #ifdef HAVE_TTY | |
| 1621 syms_of_console_tty (); | |
| 1622 syms_of_device_tty (); | |
| 771 | 1623 syms_of_frame_tty (); |
| 428 | 1624 syms_of_objects_tty (); |
| 1625 #endif | |
| 1626 | |
| 462 | 1627 #ifdef HAVE_GTK |
| 1628 syms_of_device_gtk (); | |
| 1629 syms_of_frame_gtk (); | |
| 1630 syms_of_glyphs_gtk (); | |
| 1631 syms_of_objects_gtk (); | |
| 1632 syms_of_ui_gtk (); | |
| 1633 syms_of_select_gtk (); | |
| 1634 #ifdef HAVE_DIALOGS | |
| 1635 syms_of_dialog_gtk (); | |
| 1636 #endif | |
| 1637 #ifdef HAVE_MENUBARS | |
| 1638 syms_of_menubar_gtk (); | |
| 1639 #endif | |
| 1640 syms_of_select_gtk (); | |
| 854 | 1641 |
| 771 | 1642 #ifdef HAVE_GUI_OBJECTS |
| 462 | 1643 syms_of_gui_gtk (); |
| 1644 #endif | |
| 1645 #endif /* HAVE_GTK */ | |
| 1646 | |
| 428 | 1647 #ifdef HAVE_X_WINDOWS |
| 442 | 1648 #ifdef HAVE_BALLOON_HELP |
| 440 | 1649 syms_of_balloon_x (); |
| 442 | 1650 #endif |
| 428 | 1651 syms_of_device_x (); |
| 771 | 1652 #ifdef HAVE_X_DIALOGS |
| 428 | 1653 syms_of_dialog_x (); |
| 1654 #endif | |
| 1655 syms_of_frame_x (); | |
| 1656 syms_of_glyphs_x (); | |
| 1657 syms_of_objects_x (); | |
| 1658 #ifdef HAVE_MENUBARS | |
| 1659 syms_of_menubar_x (); | |
| 1660 #endif | |
| 440 | 1661 syms_of_select_x (); |
| 771 | 1662 #ifdef HAVE_GUI_OBJECTS |
| 428 | 1663 syms_of_gui_x (); |
| 1664 #endif | |
| 771 | 1665 syms_of_intl_x (); |
| 428 | 1666 #ifdef HAVE_XIM |
| 1667 #ifdef XIM_XLIB | |
| 1668 syms_of_input_method_xlib (); | |
| 1669 #endif | |
| 1670 #endif /* HAVE_XIM */ | |
| 3094 | 1671 |
| 1672 #ifdef USE_XFT | |
| 3354 | 1673 syms_of_font_mgr(); |
| 3094 | 1674 #endif |
| 1675 | |
| 428 | 1676 #endif /* HAVE_X_WINDOWS */ |
| 1677 | |
| 1678 #ifdef HAVE_MS_WINDOWS | |
| 1679 syms_of_console_mswindows (); | |
| 1680 syms_of_device_mswindows (); | |
| 903 | 1681 syms_of_event_mswindows (); |
| 771 | 1682 #ifdef HAVE_DIALOGS |
| 442 | 1683 syms_of_dialog_mswindows (); |
| 771 | 1684 #endif |
| 428 | 1685 syms_of_frame_mswindows (); |
| 1686 syms_of_objects_mswindows (); | |
| 1687 syms_of_select_mswindows (); | |
| 1688 syms_of_glyphs_mswindows (); | |
| 771 | 1689 #ifdef HAVE_GUI_OBJECTS |
| 440 | 1690 syms_of_gui_mswindows (); |
| 771 | 1691 #endif |
| 428 | 1692 #ifdef HAVE_MENUBARS |
| 1693 syms_of_menubar_mswindows (); | |
| 1694 #endif | |
| 1695 #ifdef HAVE_SCROLLBARS | |
| 1696 syms_of_scrollbar_mswindows (); | |
| 1697 #endif | |
| 442 | 1698 #endif /* HAVE_MS_WINDOWS */ |
| 902 | 1699 #ifdef WIN32_NATIVE |
| 428 | 1700 syms_of_dired_mswindows (); |
| 771 | 1701 syms_of_nt (); |
| 428 | 1702 #endif |
| 1315 | 1703 #ifdef WIN32_ANY |
| 442 | 1704 syms_of_win32 (); |
| 1705 #endif | |
| 428 | 1706 |
| 771 | 1707 syms_of_file_coding (); |
| 1708 syms_of_unicode (); | |
| 428 | 1709 #ifdef MULE |
| 1710 syms_of_mule_ccl (); | |
| 1711 syms_of_mule_charset (); | |
| 771 | 1712 syms_of_mule_coding (); |
| 428 | 1713 #ifdef HAVE_WNN |
| 1714 syms_of_mule_wnn (); | |
| 1715 #endif | |
| 2973 | 1716 #if defined(HAVE_CANNA) && !defined (HAVE_SHLIB) |
| 1717 syms_of_canna_api (); | |
| 428 | 1718 #endif /* HAVE_CANNA */ |
| 1719 #endif /* MULE */ | |
| 1720 | |
| 1315 | 1721 #ifdef WIN32_ANY |
| 771 | 1722 syms_of_intl_win32 (); |
| 1723 #endif | |
| 1724 | |
| 428 | 1725 #ifdef SYMS_SYSTEM |
| 1726 SYMS_SYSTEM; | |
| 1727 #endif | |
| 1728 | |
| 1729 #ifdef SYMS_MACHINE | |
| 1730 SYMS_MACHINE; | |
| 1731 #endif | |
| 1732 | |
| 1733 /* | |
| 1734 #if defined (GNU_MALLOC) && \ | |
| 1735 defined (ERROR_CHECK_MALLOC) && \ | |
| 1736 !defined (HAVE_LIBMCHECK) | |
| 1737 */ | |
| 1738 /* Prior to XEmacs 21, this was `#if 0'ed out. -slb */ | |
| 1739 #if defined (LOSING_GCC_DESTRUCTOR_FREE_BUG) | |
| 1740 syms_of_free_hook (); | |
| 1741 #endif | |
| 1742 | |
| 1743 #ifdef TOOLTALK | |
| 1744 syms_of_tooltalk (); | |
| 1745 #endif | |
| 1746 | |
| 1747 #ifdef SUNPRO | |
| 1748 syms_of_sunpro (); | |
| 1749 #endif | |
| 1750 | |
| 996 | 1751 #if defined (HAVE_LDAP) && !defined (HAVE_SHLIB) |
| 428 | 1752 syms_of_eldap (); |
| 1753 #endif | |
| 1754 | |
| 1755 #ifdef HAVE_GPM | |
| 442 | 1756 syms_of_gpmevent (); |
| 1757 #endif | |
| 1758 | |
| 996 | 1759 #if defined (HAVE_POSTGRESQL) && !defined (HAVE_SHLIB) |
| 442 | 1760 syms_of_postgresql (); |
| 428 | 1761 #endif |
| 1762 | |
| 1763 /* Now create the subtypes for the types that have them. | |
| 1764 We do this before the vars_*() because more symbols | |
| 1765 may get initialized here. */ | |
| 1766 | |
| 1767 /* Now initialize the console types and associated symbols. | |
| 1768 Other than the first function below, the functions may | |
| 1769 make exactly the following function/macro calls: | |
| 1770 | |
| 1771 INITIALIZE_CONSOLE_TYPE() | |
| 1772 CONSOLE_HAS_METHOD() | |
| 1773 | |
| 1774 For any given console type, the former macro must be called | |
| 1775 before the any calls to the latter macro. */ | |
| 1776 | |
| 1777 console_type_create (); | |
| 1778 | |
| 1779 console_type_create_stream (); | |
| 1780 | |
| 1781 #ifdef HAVE_TTY | |
| 1782 console_type_create_tty (); | |
| 1783 console_type_create_device_tty (); | |
| 1784 console_type_create_frame_tty (); | |
| 1785 console_type_create_objects_tty (); | |
| 1786 console_type_create_redisplay_tty (); | |
| 1787 #endif | |
| 1788 | |
| 462 | 1789 #ifdef HAVE_GTK |
| 1790 console_type_create_gtk (); | |
| 1791 console_type_create_select_gtk (); | |
| 1792 console_type_create_device_gtk (); | |
| 1793 console_type_create_frame_gtk (); | |
| 1794 console_type_create_objects_gtk (); | |
| 1795 console_type_create_glyphs_gtk (); | |
| 1796 console_type_create_redisplay_gtk (); | |
| 1797 #ifdef HAVE_MENUBARS | |
| 1798 console_type_create_menubar_gtk (); | |
| 1799 #endif | |
| 1800 #ifdef HAVE_SCROLLBARS | |
| 1801 console_type_create_scrollbar_gtk (); | |
| 1802 #endif | |
| 1803 #ifdef HAVE_TOOLBARS | |
| 1804 console_type_create_toolbar_gtk (); | |
| 1805 #endif | |
| 1806 #ifdef HAVE_DIALOGS | |
| 1807 console_type_create_dialog_gtk (); | |
| 1808 #endif | |
| 1809 #endif /* HAVE_GTK */ | |
| 1810 | |
| 428 | 1811 #ifdef HAVE_X_WINDOWS |
| 1812 console_type_create_x (); | |
| 1813 console_type_create_device_x (); | |
| 1814 console_type_create_frame_x (); | |
| 1815 console_type_create_glyphs_x (); | |
| 1816 console_type_create_select_x (); | |
| 1817 #ifdef HAVE_MENUBARS | |
| 1818 console_type_create_menubar_x (); | |
| 1819 #endif | |
| 1820 console_type_create_objects_x (); | |
| 1821 console_type_create_redisplay_x (); | |
| 1822 #ifdef HAVE_SCROLLBARS | |
| 1823 console_type_create_scrollbar_x (); | |
| 1824 #endif | |
| 1825 #ifdef HAVE_TOOLBARS | |
| 1826 console_type_create_toolbar_x (); | |
| 1827 #endif | |
| 771 | 1828 #ifdef HAVE_X_DIALOGS |
| 428 | 1829 console_type_create_dialog_x (); |
| 1830 #endif | |
| 1831 #endif /* HAVE_X_WINDOWS */ | |
| 1832 | |
| 1833 #ifdef HAVE_MS_WINDOWS | |
| 1834 console_type_create_mswindows (); | |
| 1835 console_type_create_device_mswindows (); | |
| 1836 console_type_create_frame_mswindows (); | |
| 1837 console_type_create_objects_mswindows (); | |
| 1838 console_type_create_redisplay_mswindows (); | |
| 1839 console_type_create_glyphs_mswindows (); | |
| 1840 console_type_create_select_mswindows (); | |
| 1841 # ifdef HAVE_SCROLLBARS | |
| 1842 console_type_create_scrollbar_mswindows (); | |
| 1843 # endif | |
| 1844 #ifdef HAVE_MENUBARS | |
| 1845 console_type_create_menubar_mswindows (); | |
| 1846 #endif | |
| 1847 #ifdef HAVE_TOOLBARS | |
| 1848 console_type_create_toolbar_mswindows (); | |
| 1849 #endif | |
| 1850 #ifdef HAVE_DIALOGS | |
| 1851 console_type_create_dialog_mswindows (); | |
| 1852 #endif | |
| 1853 #endif | |
| 1854 | |
| 1855 /* Now initialize the specifier types and associated symbols. | |
| 1856 Other than the first function below, the functions may | |
| 1857 make exactly the following function/macro calls: | |
| 1858 | |
| 1859 INITIALIZE_SPECIFIER_TYPE() | |
| 1860 SPECIFIER_HAS_METHOD() | |
| 1861 | |
| 1862 For any given specifier type, the former macro must be called | |
| 1863 before the any calls to the latter macro. */ | |
| 1864 | |
| 1865 specifier_type_create (); | |
| 1866 | |
| 1867 specifier_type_create_image (); | |
| 1868 specifier_type_create_gutter (); | |
| 1869 specifier_type_create_objects (); | |
| 1870 #ifdef HAVE_TOOLBARS | |
| 1871 specifier_type_create_toolbar (); | |
| 1872 #endif | |
| 1873 | |
| 771 | 1874 /* Now initialize the coding system types and associated symbols. |
| 1875 Other than the first function below, the functions may | |
| 1876 make exactly the following function/macro calls: | |
| 1877 | |
| 1878 INITIALIZE_CODING_SYSTEM_TYPE() | |
| 1879 CODING_SYSTEM_HAS_METHOD() | |
| 1880 | |
| 1881 For any given coding system type, the former macro must be called | |
| 1882 before the any calls to the latter macro. */ | |
| 1883 | |
| 1884 coding_system_type_create (); | |
| 1885 coding_system_type_create_unicode (); | |
| 1315 | 1886 #ifdef WIN32_ANY |
| 771 | 1887 coding_system_type_create_intl_win32 (); |
| 1888 #endif | |
| 1889 #ifdef MULE | |
| 1890 coding_system_type_create_mule_coding (); | |
| 1891 #endif | |
| 1892 | |
| 428 | 1893 /* Now initialize the image instantiator formats and associated symbols. |
| 1894 Other than the first function below, the functions may | |
| 1895 make exactly the following function/macro calls: | |
| 1896 | |
| 1897 INITIALIZE_IMAGE_INSTANTIATOR_FORMAT() | |
| 1898 IIFORMAT_HAS_METHOD() | |
| 1899 IIFORMAT_VALID_KEYWORD() | |
| 1900 | |
| 1901 For any given image instantiator format, the first macro must be | |
| 1902 called before the any calls to the other macros. */ | |
| 1903 | |
| 1904 image_instantiator_format_create (); | |
| 1905 image_instantiator_format_create_glyphs_eimage (); | |
| 1906 image_instantiator_format_create_glyphs_widget (); | |
| 1907 #ifdef HAVE_TTY | |
| 1908 image_instantiator_format_create_glyphs_tty (); | |
| 1909 #endif | |
| 1910 #ifdef HAVE_X_WINDOWS | |
| 1911 image_instantiator_format_create_glyphs_x (); | |
| 1912 #endif /* HAVE_X_WINDOWS */ | |
| 1913 #ifdef HAVE_MS_WINDOWS | |
| 1914 image_instantiator_format_create_glyphs_mswindows (); | |
| 1204 | 1915 #endif /* HAVE_MS_WINDOWS */ |
| 462 | 1916 #ifdef HAVE_GTK |
| 1917 image_instantiator_format_create_glyphs_gtk (); | |
| 1918 #endif | |
| 2367 | 1919 } |
| 1920 #ifdef PDUMP | |
| 1921 else if (!restart) /* after successful pdump_load() | |
| 1922 (note, we are inside ifdef PDUMP) */ | |
| 1923 { | |
| 1924 reinit_alloc_early (); | |
| 3092 | 1925 reinit_gc_early (); |
| 2367 | 1926 reinit_symbols_early (); |
| 3263 | 1927 #ifndef NEW_GC |
| 2367 | 1928 reinit_opaque_early (); |
| 3263 | 1929 #endif /* not NEW_GC */ |
| 2367 | 1930 reinit_eistring_early (); |
| 1931 | |
| 1932 reinit_console_type_create_stream (); | |
| 1933 #ifdef HAVE_TTY | |
| 1934 reinit_console_type_create_tty (); | |
| 1935 #endif | |
| 1936 #ifdef HAVE_X_WINDOWS | |
| 1937 reinit_console_type_create_x (); | |
| 1938 reinit_console_type_create_device_x (); | |
| 1939 #endif | |
| 1940 #ifdef HAVE_MS_WINDOWS | |
| 1941 reinit_console_type_create_mswindows (); | |
| 1942 #endif | |
| 1943 #ifdef HAVE_GTK | |
| 1944 reinit_console_type_create_gtk (); | |
| 1945 #endif | |
| 1946 | |
| 1947 reinit_specifier_type_create (); | |
| 1948 reinit_specifier_type_create_image (); | |
| 1949 reinit_specifier_type_create_gutter (); | |
| 1950 reinit_specifier_type_create_objects (); | |
| 1951 #ifdef HAVE_TOOLBARS | |
| 1952 reinit_specifier_type_create_toolbar (); | |
| 1953 #endif | |
| 1954 | |
| 1955 reinit_coding_system_type_create (); | |
| 1956 reinit_coding_system_type_create_unicode (); | |
| 1957 #ifdef WIN32_ANY | |
| 1958 reinit_coding_system_type_create_intl_win32 (); | |
| 1959 #endif | |
| 1960 #ifdef MULE | |
| 1961 reinit_coding_system_type_create_mule_coding (); | |
| 1962 #endif | |
| 1963 } | |
| 1964 #endif /* PDUMP */ | |
| 1965 | |
| 1966 if (!initialized | |
| 1967 #ifdef PDUMP | |
| 1968 || !restart | |
| 1969 #endif | |
| 1970 ) | |
| 1971 { | |
| 1972 /* Now initialize the structure types and associated symbols. | |
| 1973 Other than the first function below, the functions may | |
| 1974 make exactly the following function/macro calls: | |
| 1975 | |
| 1976 define_structure_type() | |
| 1977 define_structure_type_keyword() | |
| 1978 | |
| 1979 */ | |
| 1980 | |
| 1981 structure_type_create (); | |
| 1982 | |
| 1983 structure_type_create_chartab (); | |
| 1984 structure_type_create_faces (); | |
| 1985 structure_type_create_rangetab (); | |
| 1986 structure_type_create_hash_table (); | |
| 428 | 1987 |
| 1988 /* Now initialize the lstream types and associated symbols. | |
| 1989 Other than the first function below, the functions may | |
| 1990 make exactly the following function/macro calls: | |
| 1991 | |
| 1992 LSTREAM_HAS_METHOD() | |
| 1993 | |
| 1994 */ | |
| 1995 | |
| 1996 lstream_type_create (); | |
| 1997 lstream_type_create_file_coding (); | |
| 853 | 1998 #if defined (HAVE_MS_WINDOWS) && !defined (HAVE_MSG_SELECT) |
| 428 | 1999 lstream_type_create_mswindows_selectable (); |
| 2000 #endif | |
| 2001 | |
| 2002 /* Initialize processes implementation. | |
| 2003 The functions may make exactly the following function/macro calls: | |
| 2004 | |
| 2005 PROCESS_HAS_METHOD() | |
| 2006 */ | |
| 2007 #ifdef HAVE_UNIX_PROCESSES | |
| 2008 process_type_create_unix (); | |
| 2009 #endif | |
| 2010 #ifdef HAVE_WIN32_PROCESSES | |
| 2011 process_type_create_nt (); | |
| 2012 #endif | |
| 2367 | 2013 } |
| 2014 | |
| 2015 if (!initialized) | |
| 2016 { | |
| 428 | 2017 /* Now initialize most variables. |
| 2018 | |
| 2019 These functions may do exactly the following: | |
| 2020 | |
| 771 | 2021 -- assigning a symbol or constant value to a variable |
| 2022 -- using a global variable that has been initialized | |
| 2023 earlier on in the same function | |
| 2024 -- DEFVAR_INT() | |
| 2025 -- DEFVAR_LISP() | |
| 2026 -- DEFVAR_BOOL() | |
| 2027 -- DEFER_GETTEXT() | |
| 2028 -- staticpro*() | |
| 2029 -- xmalloc*(), xnew*(), and friends | |
| 2030 -- Dynarr_*() | |
| 2031 -- Blocktype_*() | |
| 1303 | 2032 -- Fprovide (symbol) |
| 771 | 2033 -- intern() |
| 2034 -- Fput() | |
| 2035 -- dump_add_*() | |
| 2036 -- C library functions with no external dependencies, e.g. str*() | |
| 2037 -- defsymbol(), if it's absolutely necessary and you're sure that | |
| 2038 the symbol isn't referenced anywhere else in the initialization | |
| 2039 code | |
| 2040 -- Fset() on a symbol that is unbound | |
| 2041 -- Any of the object-creating functions in alloc.c: e.g. | |
| 2042 - make_string() | |
| 2043 - build_intstring() | |
| 2044 - build_string() | |
| 2045 - make_vector() | |
| 2046 - make_int() | |
| 2047 - make_char() | |
| 2048 - make_extent() | |
| 3024 | 2049 - BASIC_ALLOC_LCRECORD() |
| 2050 - ALLOC_LCRECORD_TYPE() | |
| 771 | 2051 - Fcons() |
| 2052 - listN() | |
| 2053 - make_lcrecord_list() | |
| 2054 -- make_opaque_ptr() | |
| 2055 -- make_lisp_hash_table() (not allowed in 21.4!) | |
| 2056 -- certain specifier creation functions (but be careful; see | |
| 2057 glyphs.c for examples) | |
| 428 | 2058 |
| 2059 perhaps a few others. | |
| 446 | 2060 |
| 771 | 2061 NO EXTERNAL-FORMAT CONVERSIONS. |
| 2062 | |
| 446 | 2063 NB: Initialization or assignment should not be done here to certain |
| 2064 variables settable from the command line. See the comment above | |
| 2065 the call to pdump_load() in main_1(). This caveat should only | |
| 2066 apply to vars_of_emacs(). | |
| 2367 | 2067 |
| 2068 Order should not matter in these functions. | |
| 428 | 2069 */ |
| 2070 | |
| 2071 /* Now allow Fprovide() statements to be made. */ | |
| 2072 init_provide_once (); | |
| 2073 | |
| 2074 /* Do that before any specifier creation (esp. vars_of_glyphs()) */ | |
| 2075 vars_of_specifier (); | |
| 2076 | |
| 2077 vars_of_abbrev (); | |
| 2078 vars_of_alloc (); | |
| 2079 vars_of_buffer (); | |
| 2080 vars_of_bytecode (); | |
| 2081 vars_of_callint (); | |
| 2082 vars_of_chartab (); | |
| 2083 vars_of_cmdloop (); | |
| 2084 vars_of_cmds (); | |
| 2085 vars_of_console (); | |
| 2086 vars_of_data (); | |
| 2087 #ifdef DEBUG_XEMACS | |
| 2088 vars_of_debug (); | |
| 440 | 2089 vars_of_tests (); |
| 428 | 2090 #endif |
| 2091 vars_of_console_stream (); | |
| 2092 vars_of_device (); | |
| 2093 #ifdef HAVE_DIALOGS | |
| 2094 vars_of_dialog (); | |
| 2095 #endif | |
| 2096 vars_of_dired (); | |
| 2097 vars_of_doc (); | |
| 2098 #ifdef HAVE_DRAGNDROP | |
| 2099 vars_of_dragdrop (); | |
| 2100 #endif | |
| 2101 vars_of_editfns (); | |
| 2102 vars_of_emacs (); | |
| 2103 vars_of_eval (); | |
| 2104 | |
| 2105 #ifdef HAVE_X_WINDOWS | |
| 2106 vars_of_event_Xt (); | |
| 2107 #endif | |
| 1303 | 2108 #if defined (HAVE_TTY) && (defined (DEBUG_TTY_EVENT_STREAM) || !defined (HAVE_X_WINDOWS)) |
| 428 | 2109 vars_of_event_tty (); |
| 2110 #endif | |
| 2111 #ifdef HAVE_MS_WINDOWS | |
| 2112 vars_of_event_mswindows (); | |
| 2113 #endif | |
| 2114 vars_of_event_stream (); | |
| 2115 | |
| 2116 vars_of_events (); | |
| 2117 vars_of_extents (); | |
| 2118 vars_of_faces (); | |
| 771 | 2119 vars_of_file_coding (); |
| 428 | 2120 vars_of_fileio (); |
| 444 | 2121 #ifdef CLASH_DETECTION |
| 2122 vars_of_filelock (); | |
| 2123 #endif | |
| 428 | 2124 vars_of_floatfns (); |
| 771 | 2125 vars_of_fns (); |
| 826 | 2126 #ifdef USE_C_FONT_LOCK |
| 428 | 2127 vars_of_font_lock (); |
| 826 | 2128 #endif /* USE_C_FONT_LOCK */ |
| 428 | 2129 vars_of_frame (); |
| 3092 | 2130 vars_of_gc (); |
| 428 | 2131 vars_of_glyphs (); |
| 2132 vars_of_glyphs_eimage (); | |
| 2133 vars_of_glyphs_widget (); | |
| 2134 vars_of_gui (); | |
| 2135 vars_of_gutter (); | |
| 2136 vars_of_indent (); | |
| 2137 vars_of_insdel (); | |
| 2138 vars_of_intl (); | |
| 1315 | 2139 #ifdef WIN32_ANY |
| 771 | 2140 vars_of_intl_win32 (); |
| 2141 #endif | |
| 428 | 2142 #ifdef HAVE_XIM |
| 2143 #ifdef XIM_MOTIF | |
| 2144 vars_of_input_method_motif (); | |
| 2145 #else /* XIM_XLIB */ | |
| 2146 vars_of_input_method_xlib (); | |
| 2147 #endif | |
| 2148 #endif /* HAVE_XIM */ | |
| 2149 vars_of_keymap (); | |
| 2150 vars_of_lread (); | |
| 2151 vars_of_lstream (); | |
| 2152 vars_of_macros (); | |
| 2153 vars_of_md5 (); | |
| 2154 #ifdef HAVE_DATABASE | |
| 2155 vars_of_database (); | |
| 2156 #endif | |
| 2157 #ifdef HAVE_MENUBARS | |
| 2158 vars_of_menubar (); | |
| 2159 #endif | |
| 2160 vars_of_minibuf (); | |
| 2161 vars_of_module (); | |
| 442 | 2162 #ifdef WIN32_NATIVE |
| 902 | 2163 vars_of_dired_mswindows (); |
| 440 | 2164 vars_of_nt (); |
| 428 | 2165 #endif |
| 1983 | 2166 #ifdef WITH_NUMBER_TYPES |
| 2167 vars_of_number (); | |
| 2168 #endif | |
| 428 | 2169 vars_of_objects (); |
| 2170 vars_of_print (); | |
| 2171 | |
| 2172 #ifndef NO_SUBPROCESSES | |
| 2173 vars_of_process (); | |
| 2174 #ifdef HAVE_UNIX_PROCESSES | |
| 2175 vars_of_process_unix (); | |
| 2176 #endif | |
| 2177 #ifdef HAVE_WIN32_PROCESSES | |
| 2178 vars_of_process_nt (); | |
| 2179 #endif | |
| 2180 #endif | |
| 2181 | |
| 2182 vars_of_profile (); | |
| 1303 | 2183 #if defined (HAVE_MMAP) && defined (REL_ALLOC) && !defined (DOUG_LEA_MALLOC) |
| 428 | 2184 vars_of_ralloc (); |
| 2185 #endif /* HAVE_MMAP && REL_ALLOC */ | |
| 2526 | 2186 vars_of_realpath (); |
| 428 | 2187 vars_of_redisplay (); |
| 814 | 2188 vars_of_regex (); |
| 428 | 2189 #ifdef HAVE_SCROLLBARS |
| 2190 vars_of_scrollbar (); | |
| 2191 #endif | |
| 2192 vars_of_search (); | |
| 2193 vars_of_select (); | |
| 2194 vars_of_sound (); | |
| 2195 vars_of_symbols (); | |
| 2196 vars_of_syntax (); | |
| 771 | 2197 vars_of_text (); |
| 428 | 2198 #ifdef HAVE_TOOLBARS |
| 2199 vars_of_toolbar (); | |
| 2200 #endif | |
| 2201 vars_of_undo (); | |
| 2202 vars_of_window (); | |
| 1315 | 2203 #ifdef WIN32_ANY |
| 771 | 2204 vars_of_win32 (); |
| 2205 #endif | |
| 428 | 2206 |
| 2207 #ifdef HAVE_TTY | |
| 2208 vars_of_console_tty (); | |
| 2209 vars_of_frame_tty (); | |
| 2210 vars_of_objects_tty (); | |
| 2211 #endif | |
| 2212 | |
| 462 | 2213 #ifdef HAVE_GTK |
| 2214 vars_of_device_gtk (); | |
|
4380
461fdb92f3b6
Correct the perhaps_init_unseen_key_defaults GTK code; don't override X11 fonts.
Aidan Kehoe <kehoea@parhasard.net>
parents:
3466
diff
changeset
|
2215 vars_of_console_gtk (); |
| 462 | 2216 #ifdef HAVE_DIALOGS |
| 2217 vars_of_dialog_gtk (); | |
| 2218 #endif | |
| 2219 vars_of_event_gtk (); | |
| 2220 vars_of_frame_gtk (); | |
| 2221 vars_of_glyphs_gtk (); | |
| 2222 vars_of_ui_gtk (); | |
| 2223 #ifdef HAVE_MENUBARS | |
| 2224 vars_of_menubar_gtk (); | |
| 2225 #endif | |
| 2226 vars_of_objects_gtk (); | |
| 2227 vars_of_select_gtk (); | |
| 2228 #ifdef HAVE_SCROLLBARS | |
| 2229 vars_of_scrollbar_gtk (); | |
| 2230 #endif | |
| 2231 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_DIALOGS) || defined (HAVE_TOOLBARS) | |
| 2232 vars_of_gui_gtk (); | |
| 2233 #endif | |
| 2234 #endif /* HAVE_GTK */ | |
| 2235 | |
| 428 | 2236 #ifdef HAVE_X_WINDOWS |
| 442 | 2237 #ifdef HAVE_BALLOON_HELP |
| 440 | 2238 vars_of_balloon_x (); |
| 442 | 2239 #endif |
| 3381 | 2240 vars_of_console_x (); |
| 428 | 2241 vars_of_device_x (); |
| 771 | 2242 #ifdef HAVE_X_DIALOGS |
| 428 | 2243 vars_of_dialog_x (); |
| 2244 #endif | |
| 2245 vars_of_frame_x (); | |
| 2246 vars_of_glyphs_x (); | |
| 2247 #ifdef HAVE_MENUBARS | |
| 2248 vars_of_menubar_x (); | |
| 2249 #endif | |
| 2250 vars_of_objects_x (); | |
| 440 | 2251 vars_of_select_x (); |
| 428 | 2252 #ifdef HAVE_SCROLLBARS |
| 2253 vars_of_scrollbar_x (); | |
| 2254 #endif | |
| 771 | 2255 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_X_DIALOGS) || defined (HAVE_TOOLBARS) |
| 428 | 2256 vars_of_gui_x (); |
| 2257 #endif | |
| 3094 | 2258 |
| 2259 #ifdef USE_XFT | |
| 3354 | 2260 vars_of_font_mgr (); |
| 3094 | 2261 #endif |
| 2262 | |
| 440 | 2263 #endif /* HAVE_X_WINDOWS */ |
| 428 | 2264 |
| 462 | 2265 |
| 428 | 2266 #ifdef HAVE_MS_WINDOWS |
| 2267 vars_of_device_mswindows (); | |
| 2268 vars_of_console_mswindows (); | |
| 2269 vars_of_frame_mswindows (); | |
| 2270 vars_of_objects_mswindows (); | |
| 2271 vars_of_select_mswindows (); | |
| 2272 vars_of_glyphs_mswindows (); | |
| 2273 #ifdef HAVE_SCROLLBARS | |
| 2274 vars_of_scrollbar_mswindows (); | |
| 2275 #endif | |
| 2276 #ifdef HAVE_MENUBARS | |
| 2277 vars_of_menubar_mswindows (); | |
| 2278 #endif | |
| 2279 #ifdef HAVE_DIALOGS | |
| 2280 vars_of_dialog_mswindows (); | |
| 2281 #endif | |
| 2282 #endif /* HAVE_MS_WINDOWS */ | |
| 2283 | |
| 2284 #ifdef MULE | |
| 2285 vars_of_mule_ccl (); | |
| 2286 vars_of_mule_charset (); | |
| 2287 #endif | |
| 2288 vars_of_file_coding (); | |
| 771 | 2289 vars_of_unicode (); |
| 428 | 2290 #ifdef MULE |
| 771 | 2291 vars_of_mule_coding (); |
| 428 | 2292 #ifdef HAVE_WNN |
| 2293 vars_of_mule_wnn (); | |
| 2294 #endif | |
| 2973 | 2295 #if defined(HAVE_CANNA) && !defined (HAVE_SHLIB) |
| 2296 vars_of_canna_api (); | |
| 428 | 2297 #endif /* HAVE_CANNA */ |
| 2298 #endif /* MULE */ | |
| 2299 | |
| 2300 #ifdef TOOLTALK | |
| 2301 vars_of_tooltalk (); | |
| 2302 #endif | |
| 2303 | |
| 2304 #ifdef SUNPRO | |
| 2305 vars_of_sunpro (); | |
| 2306 #endif | |
| 2307 | |
| 996 | 2308 #if defined (HAVE_LDAP) && !defined (HAVE_SHLIB) |
| 428 | 2309 vars_of_eldap (); |
| 2310 #endif | |
| 2311 | |
| 996 | 2312 #if defined (HAVE_POSTGRESQL) && !defined (HAVE_SHLIB) |
| 771 | 2313 vars_of_postgresql (); |
| 442 | 2314 #endif |
| 2315 | |
| 428 | 2316 #ifdef HAVE_GPM |
| 442 | 2317 vars_of_gpmevent (); |
| 428 | 2318 #endif |
| 2367 | 2319 } |
| 2320 | |
| 2321 if (!initialized | |
| 2322 #ifdef PDUMP | |
| 2323 || !restart | |
| 2324 #endif | |
| 2325 ) | |
| 2326 { | |
| 2327 /* Now do additional vars_of_*() initialization that happens both | |
| 2328 at dump time and after pdump load. */ | |
| 2329 reinit_vars_of_buffer (); | |
| 2330 reinit_vars_of_console (); | |
| 2331 #ifdef DEBUG_XEMACS | |
| 2332 reinit_vars_of_debug (); | |
| 2333 #endif | |
| 2334 reinit_vars_of_device (); | |
| 2335 reinit_vars_of_eval (); | |
| 2336 #if defined (HAVE_TTY) && (defined (DEBUG_TTY_EVENT_STREAM) || !defined (HAVE_X_WINDOWS)) | |
| 2337 reinit_vars_of_event_tty (); | |
| 2338 #endif | |
| 2339 reinit_vars_of_event_stream (); | |
| 2340 reinit_vars_of_events (); | |
| 2341 reinit_vars_of_extents (); | |
| 2342 reinit_vars_of_file_coding (); | |
| 2343 reinit_vars_of_fileio (); | |
| 2344 #ifdef USE_C_FONT_LOCK | |
| 2345 reinit_vars_of_font_lock (); | |
| 2346 #endif /* USE_C_FONT_LOCK */ | |
| 2347 reinit_vars_of_glyphs (); | |
| 2348 reinit_vars_of_glyphs_widget (); | |
| 2349 reinit_vars_of_insdel (); | |
| 2350 reinit_vars_of_lread (); | |
| 3263 | 2351 #ifndef NEW_GC |
| 2367 | 2352 reinit_vars_of_lstream (); |
| 3263 | 2353 #endif /* not NEW_GC */ |
| 2367 | 2354 reinit_vars_of_minibuf (); |
| 2355 #ifdef HAVE_SHLIB | |
| 2356 reinit_vars_of_module (); | |
| 2357 #endif | |
| 2358 reinit_vars_of_objects (); | |
| 2359 reinit_vars_of_print (); | |
| 2360 reinit_vars_of_search (); | |
| 2361 reinit_vars_of_text (); | |
| 2362 reinit_vars_of_undo (); | |
| 2363 reinit_vars_of_window (); | |
| 2364 | |
| 2365 #ifdef HAVE_MS_WINDOWS | |
| 2366 reinit_vars_of_event_mswindows (); | |
| 2367 reinit_vars_of_frame_mswindows (); | |
| 2368 reinit_vars_of_object_mswindows (); | |
| 2369 #endif | |
| 2370 | |
| 2371 #ifdef HAVE_GTK | |
| 2372 reinit_vars_of_event_gtk (); | |
| 2373 reinit_vars_of_menubar_gtk (); | |
| 2374 #endif | |
| 2375 | |
| 2376 #ifdef HAVE_X_WINDOWS | |
| 2377 reinit_vars_of_device_x (); | |
| 2378 reinit_vars_of_event_Xt (); | |
| 2379 #ifdef HAVE_SCROLLBARS | |
| 2380 reinit_vars_of_scrollbar_x (); | |
| 2381 #endif | |
| 2382 #ifdef HAVE_MENUBARS | |
| 2383 reinit_vars_of_menubar_x (); | |
| 2384 #endif | |
| 2385 reinit_vars_of_select_x (); | |
| 2386 #if defined (HAVE_MENUBARS) || defined (HAVE_SCROLLBARS) || defined (HAVE_X_DIALOGS) || defined (HAVE_TOOLBARS) | |
| 2387 reinit_vars_of_gui_x (); | |
| 2388 #endif | |
| 3094 | 2389 #ifdef USE_XFT |
| 3354 | 2390 reinit_vars_of_font_mgr (); |
| 3094 | 2391 #endif |
| 2367 | 2392 #endif /* HAVE_X_WINDOWS */ |
| 2393 | |
| 2394 #ifdef MULE | |
| 2395 reinit_vars_of_mule_coding (); | |
| 2396 #endif | |
| 2397 #if defined (MULE) && defined (HAVE_WNN) | |
| 2398 reinit_vars_of_mule_wnn (); | |
| 2399 #endif | |
| 2400 } | |
| 2401 | |
| 2402 if (!initialized) | |
| 2403 { | |
| 428 | 2404 /* Now initialize any specifier variables. We do this later |
| 2405 because it has some dependence on the vars initialized | |
| 2406 above. | |
| 2407 | |
| 2408 These functions should *only* initialize specifier variables, | |
| 2409 and may make use of the following functions/macros in addition | |
| 2410 to the ones listed above: | |
| 2411 | |
| 2412 DEFVAR_SPECIFIER() | |
| 2413 Fmake_specifier() | |
| 2414 set_specifier_fallback() | |
| 2415 set_specifier_caching() | |
| 2416 */ | |
| 2417 | |
| 2418 specifier_vars_of_glyphs (); | |
| 863 | 2419 specifier_vars_of_glyphs_widget (); |
| 428 | 2420 specifier_vars_of_gutter (); |
| 2421 #ifdef HAVE_MENUBARS | |
| 2422 specifier_vars_of_menubar (); | |
| 2423 #endif | |
| 2424 specifier_vars_of_redisplay (); | |
| 2425 #ifdef HAVE_SCROLLBARS | |
| 2426 specifier_vars_of_scrollbar (); | |
| 2427 #endif | |
| 2428 #ifdef HAVE_TOOLBARS | |
| 2429 specifier_vars_of_toolbar (); | |
| 2430 #endif | |
| 2431 specifier_vars_of_window (); | |
| 2432 | |
| 2433 /* Now comes all the rest of the variables that couldn't | |
| 2434 be handled above. There may be dependencies on variables | |
| 2435 initialized above, and dependencies between one complex_vars_() | |
| 2436 function and another. */ | |
| 2437 | |
| 2438 #ifdef MULE | |
| 814 | 2439 /* This depends on vars initialized in vars_of_unicode(). */ |
| 428 | 2440 complex_vars_of_mule_charset (); |
| 2441 #endif | |
| 814 | 2442 /* This one doesn't depend on anything really, and could go into |
| 2443 vars_of_(), but lots of lots of code gets called and it's easily | |
| 2444 possible that it could get changed to require being a | |
| 2445 complex_vars_of_(), for example if a charset appears anywhere, | |
| 2446 then we suddenly have dependence on the previous call. */ | |
| 428 | 2447 complex_vars_of_file_coding (); |
| 1315 | 2448 #ifdef WIN32_ANY |
| 771 | 2449 complex_vars_of_intl_win32 (); |
| 428 | 2450 #endif |
| 2451 | |
| 2367 | 2452 /* At this point we should be able to do conversion operations. |
| 2453 We have initialized things to the point that we can create Lisp | |
| 2454 objects and we have defined the basic coding systems (in the | |
| 2455 just-previous complex-vars calls). We will in fact do conversion | |
| 2456 quite soon, e.g. in complex_vars_of_glyphs_x(). */ | |
| 2457 inhibit_non_essential_conversion_operations = 0; | |
| 2458 | |
| 3094 | 2459 #ifdef USE_XFT |
| 2460 /* This uses coding systems. Must be done before faces are init'ed. */ | |
| 2461 /* not in xft reloaded #3 */ | |
| 3354 | 2462 complex_vars_of_font_mgr (); |
| 3094 | 2463 #endif |
| 2464 | |
| 771 | 2465 /* Depends on specifiers. */ |
| 2466 complex_vars_of_faces (); | |
| 2467 | |
| 428 | 2468 /* This calls allocate_glyph(), which creates specifiers |
| 2469 and also relies on a variable (Vthe_nothing_vector) initialized | |
| 771 | 2470 above. */ |
| 428 | 2471 complex_vars_of_glyphs (); |
| 2472 | |
| 2473 /* These rely on the glyphs just created in the previous function, | |
| 2474 and call Fadd_spec_to_specifier(), which relies on various | |
| 2475 variables initialized above. */ | |
| 462 | 2476 #ifdef HAVE_GTK |
| 2477 complex_vars_of_glyphs_gtk (); | |
| 2478 #endif | |
| 428 | 2479 #ifdef HAVE_X_WINDOWS |
| 2480 complex_vars_of_glyphs_x (); | |
| 2481 #endif | |
| 2482 #ifdef HAVE_MS_WINDOWS | |
| 2483 complex_vars_of_glyphs_mswindows (); | |
| 2484 #endif | |
| 2485 | |
| 2486 /* This calls Fmake_glyph_internal(). */ | |
| 2487 #ifdef HAVE_MENUBARS | |
| 2488 complex_vars_of_menubar (); | |
| 2489 #endif | |
| 2490 | |
| 617 | 2491 #ifdef HAVE_SCROLLBARS |
| 428 | 2492 /* This calls Fmake_glyph_internal(). */ |
| 2493 complex_vars_of_scrollbar (); | |
| 2494 #endif | |
| 2495 | |
| 2496 /* This calls allocate_glyph(). */ | |
| 2497 complex_vars_of_frame (); | |
| 2498 | |
| 2499 /* This calls Fcopy_category_table() under Mule, which calls who | |
| 2500 knows what. */ | |
| 2501 complex_vars_of_chartab (); | |
| 2502 | |
| 826 | 2503 /* This calls Fput_char_table(), which (under Mule) depends on the |
| 428 | 2504 charsets being initialized. */ |
| 2505 complex_vars_of_casetab (); | |
| 2506 | |
| 2507 /* This calls Fcopy_syntax_table(), which relies on char tables. */ | |
| 2508 complex_vars_of_syntax (); | |
| 2509 | |
| 2510 /* This initializes buffer-local variables, sets things up so | |
| 2511 that buffers can be created, and creates a couple of basic | |
| 2512 buffers. This depends on Vstandard_syntax_table and | |
| 2513 Vstandard_category_table (initialized in the previous | |
| 2514 functions), as well as a whole horde of variables that may | |
| 2515 have been initialized above. */ | |
| 2516 complex_vars_of_buffer (); | |
| 2517 | |
| 2518 /* This initializes console-local variables. */ | |
| 2519 complex_vars_of_console (); | |
| 2520 | |
| 2521 /* This creates a couple more buffers, and depends on the | |
| 2522 previous function. */ | |
| 2523 complex_vars_of_minibuf (); | |
| 2524 | |
| 2525 /* These two might call Ffile_name_as_directory(), which | |
| 2526 might depend on all sorts of things; I'm not sure. */ | |
| 2527 complex_vars_of_emacs (); | |
| 2528 | |
| 3092 | 2529 complex_vars_of_gc (); |
| 2530 | |
| 428 | 2531 /* This creates a couple of basic keymaps and depends on Lisp |
| 2532 hash tables and Ffset() (both of which depend on some variables | |
| 2533 initialized in the vars_of_*() section) and possibly other | |
| 2534 stuff. */ | |
| 2535 complex_vars_of_keymap (); | |
| 2536 | |
| 2537 #ifdef ERROR_CHECK_GC | |
| 2538 { | |
| 2539 extern int always_gc; | |
| 2540 if (always_gc) /* purification debugging hack */ | |
| 3092 | 2541 #ifdef NEW_GC |
| 2542 gc_full (); | |
| 2543 #else /* not NEW_GC */ | |
| 428 | 2544 garbage_collect_1 (); |
| 3092 | 2545 #endif /* not NEW_GC */ |
| 428 | 2546 } |
| 2547 #endif | |
| 1204 | 2548 } |
| 2367 | 2549 else |
| 2550 { | |
| 2551 /* We are at the equivalent place where we reset this in the | |
| 2552 non-initialized case. */ | |
| 2553 inhibit_non_essential_conversion_operations = 0; | |
| 1204 | 2554 |
| 428 | 2555 #ifdef PDUMP |
| 2367 | 2556 if (!restart) /* after successful pdump_load() |
| 2557 (note, we are inside ifdef PDUMP) */ | |
| 2558 { | |
| 2559 reinit_complex_vars_of_buffer_runtime_only (); | |
| 2560 reinit_complex_vars_of_console_runtime_only (); | |
| 2561 reinit_complex_vars_of_minibuf (); | |
| 2562 } | |
| 2563 #endif /* PDUMP */ | |
| 1204 | 2564 } |
| 2367 | 2565 |
| 2566 if (initialized) | |
| 2567 init_eval_semi_early (); | |
| 428 | 2568 |
| 2569 /* CONGRATULATIONS!!! We have successfully initialized the Lisp | |
| 2570 engine. */ | |
| 2571 | |
| 2572 /* Now do further initialization/setup of stuff that is not needed by the | |
| 2573 syms_of_() routines. This involves stuff that only is enabled in | |
| 2574 an interactive run (redisplay, user input, etc.) and stuff that is | |
| 2575 not needed until we start loading Lisp code (the reader). A lot | |
| 2576 of this stuff involves querying the current environment and needs | |
| 771 | 2577 to be done both at dump time and at run time. Some will be done |
| 2367 | 2578 only at run time, by querying the `initialized' variable. |
| 2579 | |
| 2580 The ordering of these functions is critical, especially the early ones, | |
| 2581 where there is typically a dependency from each to the previous. | |
| 2582 */ | |
| 771 | 2583 |
| 1315 | 2584 #ifdef WIN32_ANY |
| 771 | 2585 init_intl_win32 (); /* Under Windows, determine whether we use Unicode |
| 2586 or ANSI to call the system routines -- i.e. | |
| 2587 determine what the coding system `mswindows-tstr' | |
| 2588 is aliased to */ | |
| 2589 #endif | |
| 2590 init_buffer_1 (); /* Create *scratch* buffer; init_intl() is going to | |
| 2591 call Lisp code (the very first code we call), | |
| 2592 and needs a current buffer */ | |
| 2593 #ifdef MULE | |
| 2594 init_intl (); /* Figure out the locale and set native and | |
| 2595 file-name coding systems, initialize the Unicode tables | |
| 2596 so that we will be able to process non-ASCII from here | |
| 2597 on out! */ | |
| 428 | 2598 #endif |
| 2599 | |
| 814 | 2600 init_xemacs_process (); /* Set up the process environment (so that |
| 2601 egetenv works), the basic directory variables | |
| 2602 (exec-directory and so on), and stuff related | |
| 2603 to subprocesses. This should be first because | |
| 2604 many of the functions below call egetenv() to | |
| 2605 get environment variables. */ | |
| 771 | 2606 |
| 2607 #ifdef WIN32_NATIVE | |
| 2608 /* | |
| 2609 * For Win32, call init_environment() to properly enter environment/registry | |
| 2610 * variables into Vprocess_environment. | |
| 2611 */ | |
| 814 | 2612 init_mswindows_environment (); |
| 771 | 2613 #endif |
| 2614 | |
| 2615 init_initial_directory (); /* get the directory to use for the | |
| 2616 "*scratch*" buffer, etc. */ | |
| 2617 | |
| 1983 | 2618 #ifdef WITH_NUMBER_TYPES |
| 2619 /* Set up bignums, ratios, bigfloats, complex numbers. | |
| 2620 This must be done before the Lisp reader is set up. */ | |
| 2621 init_number (); | |
| 2622 #endif | |
| 2623 | |
| 428 | 2624 init_lread (); /* Set up the Lisp reader. */ |
| 2367 | 2625 init_cmdargs (argc, argv, skip_args); /* Create list Vcommand_line_args */ |
| 771 | 2626 init_buffer_2 (); /* Set default directory of *scratch* buffer */ |
| 428 | 2627 |
| 442 | 2628 #ifdef WIN32_NATIVE |
| 814 | 2629 init_nt (); |
| 771 | 2630 init_select_mswindows (); |
| 428 | 2631 #endif |
| 2632 | |
| 2633 init_redisplay (); /* Determine terminal type. | |
| 2634 init_sys_modes uses results */ | |
| 438 | 2635 init_frame (); |
| 428 | 2636 init_event_stream (); /* Set up so we can get user input. */ |
| 2637 init_macros (); /* set up so we can run macros. */ | |
| 2638 init_editfns (); /* Determine the name of the user we're running as */ | |
| 2639 #ifdef SUNPRO | |
| 2640 init_sunpro (); /* Set up Sunpro usage tracking */ | |
| 2641 #endif | |
| 1315 | 2642 #ifdef WIN32_ANY |
| 442 | 2643 init_win32 (); |
| 2644 #endif | |
| 428 | 2645 #if defined (HAVE_NATIVE_SOUND) && defined (hp9000s800) |
| 2646 init_hpplay (); | |
| 2647 #endif | |
| 996 | 2648 #if defined (HAVE_POSTGRESQL) && !defined (HAVE_SHLIB) |
| 771 | 2649 /* Set some values taken from environment variables */ |
| 2650 init_postgresql_from_environment (); | |
| 2651 #endif | |
| 428 | 2652 #ifdef HAVE_TTY |
| 2653 init_device_tty (); | |
| 2654 #endif | |
| 442 | 2655 init_console_stream (restart); /* Create the first console */ |
| 428 | 2656 |
| 2657 /* try to get the actual pathname of the exec file we are running */ | |
| 2658 if (!restart) | |
| 771 | 2659 { |
| 2660 Vinvocation_name = Fcar (Vcommand_line_args); | |
| 1303 | 2661 if (XSTRING_DATA (Vinvocation_name)[0] == '-') |
| 771 | 2662 { |
| 2663 /* XEmacs as a login shell, oh goody! */ | |
| 2664 Vinvocation_name = build_intstring (egetenv ("SHELL")); | |
| 2665 } | |
| 428 | 2666 Vinvocation_directory = Vinvocation_name; |
| 2667 | |
| 771 | 2668 if (!NILP (Ffile_name_directory (Vinvocation_name))) |
| 2669 { | |
| 2670 /* invocation-name includes a directory component -- presumably it | |
| 2671 is relative to cwd, not $PATH */ | |
| 2672 Vinvocation_directory = Fexpand_file_name (Vinvocation_name, | |
| 2673 Qnil); | |
| 2674 Vinvocation_path = Qnil; | |
| 2675 } | |
| 2676 else | |
| 2677 { | |
| 2678 Vinvocation_path = split_env_path ("PATH", NULL); | |
| 2679 locate_file (Vinvocation_path, Vinvocation_name, | |
| 2680 Vlisp_EXEC_SUFFIXES, | |
| 2681 &Vinvocation_directory, X_OK); | |
| 2682 } | |
| 2683 | |
| 2684 if (NILP (Vinvocation_directory)) | |
| 2685 Vinvocation_directory = Vinvocation_name; | |
| 2686 | |
| 2687 Vinvocation_name = Ffile_name_nondirectory (Vinvocation_directory); | |
| 2688 Vinvocation_directory = Ffile_name_directory (Vinvocation_directory); | |
| 2689 } | |
| 428 | 2690 |
| 2691 #if defined (LOCALTIME_CACHE) && defined (HAVE_TZSET) | |
| 2692 /* sun's localtime() has a bug. it caches the value of the time | |
| 2693 zone rather than looking it up every time. Since localtime() is | |
| 2694 called to bolt the undumping time into the undumped emacs, this | |
| 2695 results in localtime() ignoring the TZ environment variable. | |
| 2696 This flushes the new TZ value into localtime(). */ | |
| 2697 tzset (); | |
| 2698 #endif /* LOCALTIME_CACHE and TZSET */ | |
| 2699 | |
| 2700 load_me = Qnil; | |
| 2701 if (!initialized) | |
| 2702 { | |
| 2703 /* Handle -l loadup-and-dump, args passed by Makefile. */ | |
| 2367 | 2704 if (argc > 2 + skip_args && |
| 2705 !wext_strcmp_ascii (argv[1 + skip_args], "-l")) | |
| 2706 load_me = build_wext_string (argv[2 + skip_args], | |
| 2707 Qcommand_argument_encoding); | |
| 428 | 2708 } |
| 2709 | |
| 2710 #ifdef QUANTIFY | |
| 2711 if (initialized) | |
| 2712 quantify_start_recording_data (); | |
| 2713 #endif /* QUANTIFY */ | |
| 2714 | |
| 2715 initialized = 1; | |
| 2716 | |
| 2717 /* This never returns. */ | |
| 2718 initial_command_loop (load_me); | |
| 2719 /* NOTREACHED */ | |
| 2720 } | |
| 2721 | |
| 2722 | |
| 2723 /* Sort the args so we can find the most important ones | |
| 2724 at the beginning of argv. */ | |
| 2725 | |
| 2726 /* First, here's a table of all the standard options. */ | |
| 2727 | |
| 2728 struct standard_args | |
| 2729 { | |
| 2367 | 2730 const Ascbyte *name; |
| 2731 const Ascbyte *longname; | |
| 428 | 2732 int priority; |
| 2733 int nargs; | |
| 2734 }; | |
| 2735 | |
| 442 | 2736 static const struct standard_args standard_args[] = |
| 428 | 2737 { |
| 776 | 2738 /* Handled by main_1 above: Each must have its own priority and must be |
| 2739 in the order mentioned in main_1. */ | |
| 442 | 2740 { "-sd", "--show-dump-id", 105, 0 }, |
| 2741 { "-nd", "--no-dump-file", 95, 0 }, | |
| 826 | 2742 { "-batch", "--batch", 88, 0 }, |
|
4448
fd8a9a4d81d9
Support #!, to allow XEmacs to be called as a script interpreter.
Aidan Kehoe <kehoea@parhasard.net>
parents:
4380
diff
changeset
|
2743 { "-script", "--script", 89, 1 }, |
| 771 | 2744 #ifdef WIN32_NATIVE |
| 826 | 2745 { "-mswindows-termination-handle", 0, 84, 1 }, |
| 771 | 2746 { "-nuni", "--no-unicode-lib-calls", 83, 0 }, |
| 2747 #endif /* WIN32_NATIVE */ | |
| 428 | 2748 { "-debug-paths", "--debug-paths", 82, 0 }, |
| 776 | 2749 { "-no-packages", "--no-packages", 81, 0 }, |
| 2750 { "-no-early-packages", "--no-early-packages", 80, 0 }, | |
| 2751 { "-no-site-modules", "--no-site-modules", 78, 0 }, | |
| 2752 { "-vanilla", "--vanilla", 76, 0 }, | |
| 2753 { "-no-autoloads", "--no-autoloads", 74, 0 }, | |
| 2754 { "-help", "--help", 72, 0 }, | |
| 2755 { "-version", "--version", 70, 0 }, | |
| 2756 { "-V", 0, 68, 0 }, | |
| 1315 | 2757 { "-nw", "--no-windows", 66, 0 }, |
| 2758 { "-tty", "--use-tty", 65, 0 }, | |
| 2759 { "-x", "--use-x", 64, 0 }, | |
| 2760 { "-gtk", "--use-gtk", 63, 0 }, | |
| 2761 { "-gnome", "--use-gnome", 62, 0 }, | |
| 2762 { "-msw", "--use-ms-windows", 61, 0 }, | |
| 2763 { "-t", "--terminal", 58, 1 }, | |
| 2764 { "-d", "--display", 57, 1 }, | |
| 2765 { "-display", 0, 56, 1 }, | |
| 428 | 2766 |
| 2767 /* Handled by command-line-early in startup.el: */ | |
| 2768 { "-q", "--no-init-file", 50, 0 }, | |
| 2769 { "-no-init-file", 0, 50, 0 }, | |
| 776 | 2770 { "-no-site-file", "--no-site-file", 50, 0 }, |
| 2771 { "-unmapped", "--unmapped", 50, 0 }, | |
| 2772 { "-u", "--user", 50, 1 }, | |
| 2773 { "-user", 0, 50, 1 }, | |
| 2774 { "-user-init-file", "--user-init-file", 50, 1 }, | |
| 2775 { "-user-init-directory", "--user-init-directory", 50, 1 }, | |
| 2776 { "-debug-init", "--debug-init", 50, 0 }, | |
| 428 | 2777 |
| 2778 /* Xt options: */ | |
| 2779 { "-i", "--icon-type", 15, 0 }, | |
| 2780 { "-itype", 0, 15, 0 }, | |
| 2781 { "-iconic", "--iconic", 15, 0 }, | |
| 2782 { "-bg", "--background-color", 10, 1 }, | |
| 2783 { "-background", 0, 10, 1 }, | |
| 2784 { "-fg", "--foreground-color", 10, 1 }, | |
| 2785 { "-foreground", 0, 10, 1 }, | |
| 2786 { "-bd", "--border-color", 10, 1 }, | |
| 2787 { "-bw", "--border-width", 10, 1 }, | |
| 2788 { "-ib", "--internal-border", 10, 1 }, | |
| 2789 { "-ms", "--mouse-color", 10, 1 }, | |
| 2790 { "-cr", "--cursor-color", 10, 1 }, | |
| 2791 { "-fn", "--font", 10, 1 }, | |
| 2792 { "-font", 0, 10, 1 }, | |
| 2793 { "-g", "--geometry", 10, 1 }, | |
| 2794 { "-geometry", 0, 10, 1 }, | |
| 2795 { "-T", "--title", 10, 1 }, | |
| 2796 { "-title", 0, 10, 1 }, | |
| 2797 { "-name", "--name", 10, 1 }, | |
| 2798 { "-xrm", "--xrm", 10, 1 }, | |
| 2799 { "-r", "--reverse-video", 5, 0 }, | |
| 2800 { "-rv", 0, 5, 0 }, | |
| 2801 { "-reverse", 0, 5, 0 }, | |
| 2802 { "-hb", "--horizontal-scroll-bars", 5, 0 }, | |
| 2803 { "-vb", "--vertical-scroll-bars", 5, 0 }, | |
| 2804 | |
| 776 | 2805 { "-eol", "--enable-eol-detection", 2, 0 }, |
| 2806 { "-enable-eol-detection", 0, 2, 0 }, | |
| 428 | 2807 /* These have the same priority as ordinary file name args, |
| 2808 so they are not reordered with respect to those. */ | |
| 2809 { "-L", "--directory", 0, 1 }, | |
| 2810 { "-directory", 0, 0, 1 }, | |
| 2811 { "-l", "--load", 0, 1 }, | |
| 2812 { "-load", 0, 0, 1 }, | |
| 2813 { "-f", "--funcall", 0, 1 }, | |
| 2814 { "-funcall", 0, 0, 1 }, | |
| 2815 { "-eval", "--eval", 0, 1 }, | |
| 2816 { "-insert", "--insert", 0, 1 }, | |
| 2817 /* This should be processed after ordinary file name args and the like. */ | |
| 2818 { "-kill", "--kill", -10, 0 }, | |
| 2819 }; | |
| 2820 | |
| 2821 /* Reorder the elements of ARGV (assumed to have ARGC elements) | |
| 2822 so that the highest priority ones come first. | |
| 2823 Do not change the order of elements of equal priority. | |
| 2824 If an option takes an argument, keep it and its argument together. */ | |
| 2825 | |
| 2826 static void | |
| 2367 | 2827 sort_args (int argc, Wexttext **argv) |
| 428 | 2828 { |
| 2367 | 2829 Wexttext **new_argv = xnew_array (Wexttext *, argc); |
| 428 | 2830 /* For each element of argv, |
| 2831 the corresponding element of options is: | |
| 2832 0 for an option that takes no arguments, | |
| 2833 1 for an option that takes one argument, etc. | |
| 2834 -1 for an ordinary non-option argument. */ | |
| 2835 int *options = xnew_array (int, argc); | |
| 2836 int *priority = xnew_array (int, argc); | |
| 2837 int to = 1; | |
| 2838 int from; | |
| 2839 int i; | |
| 2840 int end_of_options_p = 0; | |
| 2841 | |
| 2842 /* Categorize all the options, | |
| 2843 and figure out which argv elts are option arguments. */ | |
| 2844 for (from = 1; from < argc; from++) | |
| 2845 { | |
| 2846 options[from] = -1; | |
| 2847 priority[from] = 0; | |
| 2848 /* Pseudo options "--" and "run-temacs" indicate end of options */ | |
| 2367 | 2849 if (!wext_strcmp_ascii (argv[from], "--") || |
| 2850 !wext_strcmp_ascii (argv[from], "run-temacs")) | |
| 428 | 2851 end_of_options_p = 1; |
| 2852 if (!end_of_options_p && argv[from][0] == '-') | |
| 2853 { | |
| 2367 | 2854 int match; |
| 2855 Charcount thislen; | |
| 2856 Wexttext *equals; | |
| 428 | 2857 |
| 2858 /* Look for a match with a known old-fashioned option. */ | |
| 2859 for (i = 0; i < countof (standard_args); i++) | |
| 2367 | 2860 if (!wext_strcmp_ascii (argv[from], standard_args[i].name)) |
| 428 | 2861 { |
| 2862 options[from] = standard_args[i].nargs; | |
| 2863 priority[from] = standard_args[i].priority; | |
| 2864 if (from + standard_args[i].nargs >= argc) | |
| 2367 | 2865 fatal ("Option `%s' requires an argument\n", |
| 2866 WEXTTEXT_TO_8_BIT (argv[from])); | |
| 428 | 2867 from += standard_args[i].nargs; |
| 2868 goto done; | |
| 2869 } | |
| 2870 | |
| 2871 /* Look for a match with a known long option. | |
| 2872 MATCH is -1 if no match so far, -2 if two or more matches so far, | |
| 2873 >= 0 (the table index of the match) if just one match so far. */ | |
| 2874 if (argv[from][1] == '-') | |
| 2875 { | |
| 2876 match = -1; | |
| 2367 | 2877 thislen = wext_strlen (argv[from]); |
| 2878 equals = wext_strchr (argv[from], '='); | |
| 428 | 2879 if (equals != 0) |
| 2880 thislen = equals - argv[from]; | |
| 2881 | |
| 2882 for (i = 0; i < countof (standard_args); i++) | |
| 2883 if (standard_args[i].longname | |
| 2367 | 2884 && !wext_strncmp_ascii (argv[from], |
| 2885 standard_args[i].longname, | |
| 2886 thislen)) | |
| 428 | 2887 { |
| 2888 if (match == -1) | |
| 2889 match = i; | |
| 2890 else | |
| 2891 match = -2; | |
| 2892 } | |
| 2893 | |
| 2894 /* If we found exactly one match, use that. */ | |
| 2895 if (match >= 0) | |
| 2896 { | |
| 2897 options[from] = standard_args[match].nargs; | |
| 2898 priority[from] = standard_args[match].priority; | |
| 2899 /* If --OPTION=VALUE syntax is used, | |
| 2900 this option uses just one argv element. */ | |
| 2901 if (equals != 0) | |
| 2902 options[from] = 0; | |
| 2903 if (from + options[from] >= argc) | |
| 2367 | 2904 fatal ("Option `%s' requires an argument\n", |
| 2905 WEXTTEXT_TO_8_BIT (argv[from])); | |
| 428 | 2906 from += options[from]; |
| 2907 } | |
| 2908 } | |
| 2909 done: ; | |
| 2910 } | |
| 2911 } | |
| 2912 | |
| 2913 /* Copy the arguments, in order of decreasing priority, to NEW_ARGV. */ | |
| 2914 new_argv[0] = argv[0]; | |
| 2915 while (to < argc) | |
| 2916 { | |
| 2917 int best = -1; | |
| 2918 int best_priority = -9999; | |
| 2919 | |
| 2920 /* Find the highest priority remaining option. | |
| 2921 If several have equal priority, take the first of them. */ | |
| 2922 for (from = 1; from < argc; from++) | |
| 2923 { | |
| 2924 if (argv[from] != 0 && priority[from] > best_priority) | |
| 2925 { | |
| 2926 best_priority = priority[from]; | |
| 2927 best = from; | |
| 2928 } | |
| 2929 /* Skip option arguments--they are tied to the options. */ | |
| 2930 if (options[from] > 0) | |
| 2931 from += options[from]; | |
| 2932 } | |
| 2933 | |
| 2934 if (best < 0) | |
| 2500 | 2935 ABORT (); |
| 428 | 2936 |
| 1315 | 2937 /* Copy the highest priority remaining option, with its args, to |
| 2938 NEW_ARGV. */ | |
| 428 | 2939 new_argv[to++] = argv[best]; |
| 2940 for (i = 0; i < options[best]; i++) | |
| 2941 new_argv[to++] = argv[best + i + 1]; | |
| 2942 | |
| 2943 /* Clear out this option in ARGV. */ | |
| 2944 argv[best] = 0; | |
| 2945 for (i = 0; i < options[best]; i++) | |
| 2946 argv[best + i + 1] = 0; | |
| 2947 } | |
| 2948 | |
| 2367 | 2949 memcpy (argv, new_argv, sizeof (Wexttext *) * argc); |
| 2950 xfree (new_argv, Wexttext **); | |
| 1726 | 2951 xfree (options, int *); |
| 2952 xfree (priority, int *); | |
| 428 | 2953 } |
| 2954 | |
| 2955 DEFUN ("running-temacs-p", Frunning_temacs_p, 0, 0, 0, /* | |
| 2956 True if running temacs. This means we are in the dumping stage. | |
| 2957 This is false during normal execution of the `xemacs' program, and | |
| 2958 becomes false once `run-emacs-from-temacs' is run. | |
| 2959 */ | |
| 2960 ()) | |
| 2961 { | |
| 2962 return run_temacs_argc >= 0 ? Qt : Qnil; | |
| 2963 } | |
| 2964 | |
| 1315 | 2965 DEFUN ("emacs-run-status", Femacs_run_status, 0, 0, 0, /* |
| 2966 Plist of values indicating the current run status of this XEmacs. | |
| 2967 Currently defined values: | |
| 2968 | |
| 2969 `temacs' | |
| 2970 If non-nil, we are running a "raw temacs" (no dump data is present | |
| 2971 and `run-emacs-from-temacs' not called). (same as `running-temacs-p') | |
| 2972 | |
| 2973 `dumping' | |
| 2974 If non-nil, we are in the process of creating dump data. (same as | |
| 2975 `purify-flag') | |
| 2976 | |
| 2977 `restarted' | |
| 2978 If non-nil, `run-emacs-from-temacs' was called. | |
| 2979 | |
| 2980 `pdump' | |
| 2981 If non-nil, we were compiled with pdump (portable dumping) support. | |
| 2982 | |
| 2983 `batch' | |
| 2984 If non-nil, we are running non-interactively. (same as `noninteractive') | |
| 2985 */ | |
| 2986 ()) | |
| 2987 { | |
| 2988 Lisp_Object plist = Qnil; | |
| 2989 | |
| 2990 #define ADD_PLIST(key, val) plist = Fcons (val, Fcons (key, plist)) | |
| 2991 if (run_temacs_argc >= 0) | |
| 2992 ADD_PLIST (Qtemacs, Qt); | |
| 2993 if (purify_flag) | |
| 2994 ADD_PLIST (Qdumping, Qt); | |
| 2995 if (run_temacs_argc == -2) | |
| 2996 ADD_PLIST (Qrestarted, Qt); | |
| 2997 #ifdef PDUMP | |
| 2998 ADD_PLIST (Qpdump, Qt); | |
| 2999 #endif | |
| 3000 if (noninteractive) | |
| 3001 ADD_PLIST (Qbatch, Qt); | |
| 3002 | |
| 3003 #undef ADD_PLIST | |
| 3004 return Fnreverse (plist); | |
| 3005 } | |
| 3006 | |
| 2268 | 3007 DEFUN_NORETURN ("run-emacs-from-temacs", Frun_emacs_from_temacs, 0, MANY, 0, /* |
| 428 | 3008 Do not call this. It will reinitialize your XEmacs. You'll be sorry. |
| 3009 */ | |
| 3010 /* If this function is called from startup.el, it will be possible to run | |
|
4477
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4458
diff
changeset
|
3011 temacs as an editor using `temacs -batch -l ../lisp/loadup.el |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4458
diff
changeset
|
3012 run-temacs', instead of having to dump an emacs and then run that (when |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4458
diff
changeset
|
3013 debugging emacs itself, this can be much faster)). [Actually, the speed |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4458
diff
changeset
|
3014 difference isn't that much as long as your filesystem is local, and you |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4458
diff
changeset
|
3015 don't end up with a dumped version in case you want to rerun it. This |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4458
diff
changeset
|
3016 function is most useful when used as part of the `make all-elc' |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4458
diff
changeset
|
3017 command. --ben] This will "restart" emacs with the specified command-line |
|
e34711681f30
Don't determine whether to call general device-type code at startup,
Aidan Kehoe <kehoea@parhasard.net>
parents:
4458
diff
changeset
|
3018 arguments. |
| 428 | 3019 |
| 3020 Martin thinks this function is most useful when using debugging | |
| 3021 tools like Purify or tcov that get confused by XEmacs' dumping. */ | |
| 3022 (int nargs, Lisp_Object *args)) | |
| 3023 { | |
| 2367 | 3024 int i; |
| 428 | 3025 |
| 3092 | 3026 #ifdef NEW_GC |
| 3027 if (gc_in_progress) gc_full (); | |
| 3028 #else /* not NEW_GC */ | |
| 428 | 3029 assert (!gc_in_progress); |
| 3092 | 3030 #endif /* not NEW_GC */ |
| 428 | 3031 |
| 3032 if (run_temacs_argc < 0) | |
| 2367 | 3033 invalid_operation ("I've lost my temacs-hood", Qunbound); |
| 3034 | |
| 3035 run_temacs_argc = nargs + 1; | |
| 3036 run_temacs_argv = xnew_array (Wexttext *, nargs + 2); | |
| 3037 | |
| 3038 LISP_STRING_TO_EXTERNAL_MALLOC (Fcar (Vcommand_line_args), | |
| 3039 run_temacs_argv[0], | |
| 3040 Qcommand_argument_encoding); | |
| 3041 for (i = 0; i < nargs; i++) | |
| 428 | 3042 { |
| 2367 | 3043 CHECK_STRING (args[i]); |
| 3044 | |
| 3045 LISP_STRING_TO_EXTERNAL_MALLOC (args[i], run_temacs_argv[i + 1], | |
| 3046 Qcommand_argument_encoding); | |
| 428 | 3047 } |
| 2367 | 3048 run_temacs_argv[nargs + 1] = 0; |
| 3049 | |
| 428 | 3050 catchlist = NULL; /* Important! Otherwise free_cons() calls in |
| 3051 condition_case_unwind() may lead to GC death. */ | |
| 771 | 3052 unbind_to (0); /* this closes loadup.el */ |
| 428 | 3053 purify_flag = 0; |
| 1303 | 3054 #if defined (HEAP_IN_DATA) && !defined (PDUMP) |
| 428 | 3055 report_sheap_usage (0); |
| 3056 #endif | |
| 1315 | 3057 |
| 3058 /* run-temacs usually only occurs as a result of building, and in all such | |
| 3059 cases we want a backtrace, even if it occurs very early. */ | |
| 3060 if (NILP (Vstack_trace_on_error)) | |
| 3061 Vstack_trace_on_error = Qt; | |
| 3062 | |
| 428 | 3063 LONGJMP (run_temacs_catch, 1); |
| 1204 | 3064 RETURN_NOT_REACHED (Qnil); |
| 428 | 3065 } |
| 3066 | |
| 3067 /* ARGSUSED */ | |
| 3068 int | |
| 2367 | 3069 main (int argc, Extbyte **argv, Extbyte **UNUSED (envp)) |
| 428 | 3070 { |
| 442 | 3071 |
| 3072 #ifdef _MSC_VER | |
| 3073 /* Under VC++, access violations and the like are not sent through | |
| 3074 the standard signal() mechanism. Rather, they need to be handled | |
| 3075 using the Microsoft "structured exception handling" mechanism, | |
| 3076 which vaguely resembles the C++ mechanisms. */ | |
| 3077 __try | |
| 3078 { | |
| 3079 #endif | |
| 3080 | |
| 428 | 3081 int volatile vol_argc = argc; |
| 2367 | 3082 Wexttext ** volatile vol_argv; |
| 428 | 3083 /* This is hairy. We need to compute where the XEmacs binary was invoked |
| 3084 from because temacs initialization requires it to find the lisp | |
| 3085 directories. The code that recomputes the path is guarded by the | |
| 3086 restarted flag. There are three possible paths I've found so far | |
| 3087 through this: | |
| 3088 | |
| 3089 temacs -- When running temacs for basic build stuff, the first main_1 | |
| 3090 will be the only one invoked. It must compute the path else there | |
| 3091 will be a very ugly bomb in startup.el (can't find obvious location | |
| 3092 for doc-directory data-directory, etc.). | |
| 3093 | |
| 3094 temacs w/ run-temacs on the command line -- This is run to bytecompile | |
| 3095 all the out of date dumped lisp. It will execute both of the main_1 | |
| 3096 calls and the second one must not touch the first computation because | |
| 3097 argc/argv are hosed the second time through. | |
| 3098 | |
| 3099 xemacs -- Only the second main_1 is executed. The invocation path must | |
| 3100 computed but this only matters when running in place or when running | |
| 3101 as a login shell. | |
| 3102 | |
| 3103 As a bonus for straightening this out, XEmacs can now be run in place | |
| 3104 as a login shell. This never used to work. | |
| 3105 | |
| 3106 As another bonus, we can now guarantee that | |
| 3107 (concat invocation-directory invocation-name) contains the filename | |
| 3108 of the XEmacs binary we are running. This can now be used in a | |
| 3109 definite test for out of date dumped files. -slb */ | |
| 3110 int restarted = 0; | |
| 3111 #ifdef QUANTIFY | |
| 3112 quantify_stop_recording_data (); | |
| 3113 quantify_clear_data (); | |
| 3114 #endif /* QUANTIFY */ | |
| 3115 | |
| 2367 | 3116 inhibit_non_essential_conversion_operations = 1; |
| 428 | 3117 suppress_early_error_handler_backtrace = 0; |
| 3118 lim_data = 0; /* force reinitialization of this variable */ | |
| 3119 | |
| 3120 /* Lisp_Object must fit in a word; check VALBITS and GCTYPEBITS */ | |
| 3121 assert (sizeof (Lisp_Object) == sizeof (void *)); | |
| 3122 | |
| 3123 #ifdef LINUX_SBRK_BUG | |
| 3124 sbrk (1); | |
| 3125 #endif | |
| 3126 | |
| 2367 | 3127 #ifdef WIN32_ANY |
| 3128 /* Figure out which version we're running so XEUNICODE_P works */ | |
| 3129 init_win32_very_very_early (); | |
| 3130 #endif | |
| 3131 | |
| 3132 #ifdef WIN32_NATIVE | |
| 3133 #if 0 | |
| 3134 /* !!#### We should be doing something like this, but this messes up | |
| 3135 globbing. I tried using wmain() and linking with WSETARGV, but the | |
| 3136 routines for WSETARGV are left out of MSVCRT.DLL! | |
| 3137 | |
| 3138 To fix this we need to copy the argument-expanding and globbing code | |
| 3139 from Cygwin and Unicode-ize it. Yuck. */ | |
| 3140 if (XEUNICODE_P) | |
| 3141 /* Set up Unicode versions of the arguments. */ | |
| 3142 vol_argv = CommandLineToArgvW (GetCommandLineW (), &vol_argc); | |
| 3143 #else | |
| 3144 { | |
| 3145 int i; | |
| 3146 | |
| 3147 vol_argv = alloca_array (Wexttext *, argc); | |
| 3148 for (i = 0; i < argc; i++) | |
| 3149 vol_argv[i] = MULTIBYTE_TO_WEXTTEXT (argv[i]); | |
| 3150 } | |
| 3151 #endif | |
| 3152 #else | |
| 3153 vol_argv = (Wexttext **) argv; | |
| 3154 #endif /* WIN32_NATIVE */ | |
| 3155 | |
| 428 | 3156 if (!initialized) |
| 3157 { | |
| 3158 #ifdef DOUG_LEA_MALLOC | |
| 3159 mallopt (M_MMAP_MAX, 0); | |
| 3160 #endif | |
| 3161 run_temacs_argc = 0; | |
| 3162 if (! SETJMP (run_temacs_catch)) | |
| 3163 { | |
| 2367 | 3164 main_1 (vol_argc, vol_argv, NULL, 0); |
| 428 | 3165 } |
| 3166 /* run-emacs-from-temacs called */ | |
| 3167 restarted = 1; | |
| 3168 vol_argc = run_temacs_argc; | |
| 3169 vol_argv = run_temacs_argv; | |
| 3170 #ifdef _SCO_DS | |
| 3171 /* This makes absolutely no sense to anyone involved. There are | |
| 3172 several people using this stuff. We've compared versions on | |
| 3173 everything we can think of. We can find no difference. | |
| 3174 However, on both my systems environ is a plain old global | |
| 3175 variable initialized to zero. _environ is the one that | |
| 3176 contains pointers to the actual environment. | |
| 3177 | |
| 3178 Since we can't figure out the difference (and we're hours | |
| 3179 away from a release), this takes a very cowardly approach and | |
| 3180 is bracketed with both a system specific preprocessor test | |
| 3181 and a runtime "do you have this problem" test | |
| 3182 | |
| 3183 06/20/96 robertl@dgii.com */ | |
| 3184 { | |
| 2367 | 3185 extern Extbyte *_environ; |
| 3186 if (environ == NULL) | |
| 1315 | 3187 environ = _environ; |
| 428 | 3188 } |
| 3189 #endif /* _SCO_DS */ | |
| 3190 } | |
| 456 | 3191 #if defined (RUN_TIME_REMAP) && ! defined (PDUMP) |
| 428 | 3192 else |
| 3193 /* obviously no-one uses this because where it was before initialized was | |
| 3194 *always* true */ | |
| 3195 run_time_remap (argv[0]); | |
| 3196 #endif | |
| 3197 | |
| 3198 #ifdef DOUG_LEA_MALLOC | |
| 3199 if (initialized && (malloc_state_ptr != NULL)) | |
| 3200 { | |
| 3201 int rc = malloc_set_state (malloc_state_ptr); | |
| 3202 if (rc != 0) | |
| 3203 { | |
| 442 | 3204 stderr_out ("malloc_set_state failed, rc = %d\n", rc); |
| 2500 | 3205 ABORT (); |
| 428 | 3206 } |
| 3207 #if 0 | |
| 3208 free (malloc_state_ptr); | |
| 3209 #endif | |
| 3210 /* mmap works in glibc-2.1, glibc-2.0 (Non-Mule only) and Linux libc5 */ | |
| 1303 | 3211 #if (defined (__GLIBC__) && __GLIBC_MINOR__ >= 1) || \ |
| 3212 defined (_NO_MALLOC_WARNING_) || \ | |
| 3213 (defined (__GLIBC__) && __GLIBC_MINOR__ < 1 && !defined (MULE)) || \ | |
| 3214 defined (DEBUG_DOUG_LEA_MALLOC) | |
| 428 | 3215 mallopt (M_MMAP_MAX, 64); |
| 3216 #endif | |
| 3217 #ifdef REL_ALLOC | |
| 3218 r_alloc_reinit (); | |
| 3219 #endif | |
| 3220 } | |
| 3221 #endif /* DOUG_LEA_MALLOC */ | |
| 3222 | |
| 1315 | 3223 run_temacs_argc = -2; |
| 428 | 3224 |
| 2367 | 3225 main_1 (vol_argc, vol_argv, NULL, restarted); |
| 442 | 3226 |
| 3227 #ifdef _MSC_VER | |
| 3228 } | |
| 3229 /* VC++ documentation says that | |
| 3230 GetExceptionCode() cannot be called inside the filter itself. */ | |
| 3231 __except (mswindows_handle_hardware_exceptions (GetExceptionCode ())) {} | |
| 3232 #endif | |
| 3233 | |
| 1204 | 3234 RETURN_NOT_REACHED (0); |
| 428 | 3235 } |
| 3236 | |
| 3237 | |
| 771 | 3238 /************************************************************************/ |
| 3239 /* dumping XEmacs (to a new EXE file) */ | |
| 3240 /************************************************************************/ | |
| 3241 | |
| 1204 | 3242 #if !defined (PDUMP) || !defined (SYSTEM_MALLOC) |
| 2367 | 3243 extern Rawbyte my_edata[]; |
| 428 | 3244 #endif |
| 771 | 3245 |
| 3246 extern void disable_free_hook (void); | |
| 3247 | |
| 3248 DEFUN ("dump-emacs", Fdump_emacs, 2, 2, 0, /* | |
| 3249 Dump current state of XEmacs into executable file FILENAME. | |
| 3250 Take symbols from SYMFILE (presumably the file you executed to run XEmacs). | |
| 3251 This is used in the file `loadup.el' when building XEmacs. | |
| 3252 | |
| 3253 Remember to set `command-line-processed' to nil before dumping | |
| 3254 if you want the dumped XEmacs to process its command line | |
| 3255 and announce itself normally when it is run. | |
| 428 | 3256 */ |
| 771 | 3257 (filename, symfile)) |
| 428 | 3258 { |
| 3259 /* This function can GC */ | |
| 771 | 3260 struct gcpro gcpro1, gcpro2; |
| 3261 int opurify; | |
| 3262 | |
| 3263 GCPRO2 (filename, symfile); | |
| 3264 | |
| 3265 #ifdef FREE_CHECKING | |
| 3266 Freally_free (Qnil); | |
| 3267 | |
| 3268 /* When we're dumping, we can't use the debugging free() */ | |
| 3269 disable_free_hook (); | |
| 3270 #endif | |
| 3271 | |
| 3272 CHECK_STRING (filename); | |
| 3273 filename = Fexpand_file_name (filename, Qnil); | |
| 3274 if (!NILP (symfile)) | |
| 428 | 3275 { |
| 771 | 3276 CHECK_STRING (symfile); |
| 3277 if (XSTRING_LENGTH (symfile) > 0) | |
| 3278 symfile = Fexpand_file_name (symfile, Qnil); | |
| 3279 else | |
| 3280 symfile = Qnil; | |
| 428 | 3281 } |
| 3282 | |
| 771 | 3283 opurify = purify_flag; |
| 3284 purify_flag = 0; | |
| 3285 | |
| 1303 | 3286 #if defined (HEAP_IN_DATA) && !defined (PDUMP) |
| 771 | 3287 report_sheap_usage (1); |
| 3288 #endif | |
| 3289 | |
| 3290 clear_message (); | |
| 3291 | |
| 3292 fflush (stderr); | |
| 3293 fflush (stdout); | |
| 3294 | |
| 3295 disksave_object_finalization (); | |
| 3263 | 3296 #ifndef NEW_GC |
| 771 | 3297 release_breathing_space (); |
| 3263 | 3298 #endif /* not NEW_GC */ |
| 771 | 3299 |
| 3300 /* Tell malloc where start of impure now is */ | |
| 3301 /* Also arrange for warnings when nearly out of space. */ | |
| 3302 #ifndef SYSTEM_MALLOC | |
| 3303 memory_warnings (my_edata, malloc_warning); | |
| 3304 #endif | |
| 3305 | |
| 3092 | 3306 #ifdef NEW_GC |
| 3307 gc_full (); | |
| 3308 #else /* not NEW_GC */ | |
| 814 | 3309 garbage_collect_1 (); |
| 3092 | 3310 #endif /* not NEW_GC */ |
| 814 | 3311 |
| 3312 #ifdef PDUMP | |
| 3313 pdump (); | |
| 3314 #elif defined (WIN32_NATIVE) | |
| 3315 unexec (XSTRING_DATA (filename), | |
| 3316 STRINGP (symfile) ? XSTRING_DATA (symfile) : 0, | |
| 3317 (uintptr_t) my_edata, 0, 0); | |
| 3318 #else | |
| 771 | 3319 { |
| 3320 Extbyte *filename_ext; | |
| 3321 Extbyte *symfile_ext; | |
| 3322 | |
| 3323 LISP_STRING_TO_EXTERNAL (filename, filename_ext, Qfile_name); | |
| 3324 | |
| 3325 if (STRINGP (symfile)) | |
| 3326 LISP_STRING_TO_EXTERNAL (symfile, symfile_ext, Qfile_name); | |
| 3327 else | |
| 3328 symfile_ext = 0; | |
| 3329 | |
| 814 | 3330 # ifdef DOUG_LEA_MALLOC |
| 771 | 3331 malloc_state_ptr = malloc_get_state (); |
| 814 | 3332 # endif |
| 771 | 3333 /* here we break our rule that the filename conversion should |
| 3334 be performed at the actual time that the system call is made. | |
| 3335 It's a whole lot easier to do the conversion here than to | |
| 3336 modify all the unexec routines to ensure that filename | |
| 3337 conversion is applied everywhere. Don't worry about memory | |
| 3338 leakage because this call only happens once. */ | |
| 3339 unexec (filename_ext, symfile_ext, (uintptr_t) my_edata, 0, 0); | |
| 814 | 3340 # ifdef DOUG_LEA_MALLOC |
| 771 | 3341 free (malloc_state_ptr); |
| 814 | 3342 # endif |
| 771 | 3343 } |
| 814 | 3344 #endif /* not PDUMP, not WIN32_NATIVE */ |
| 771 | 3345 |
| 3346 purify_flag = opurify; | |
| 3347 | |
| 814 | 3348 UNGCPRO; |
| 771 | 3349 return Qnil; |
| 3350 } | |
| 3351 | |
| 3352 | |
| 3353 /************************************************************************/ | |
| 3354 /* exiting XEmacs (intended or not) */ | |
| 3355 /************************************************************************/ | |
| 3356 | |
| 2367 | 3357 /* |
| 3358 | |
| 3359 Info on intended/unintended exits: | |
| 3360 | |
| 3361 (Info-goto-node "(internals)Exiting") | |
| 771 | 3362 */ |
| 3363 | |
| 3364 /* ------------------------------- */ | |
| 3365 /* low-level debugging functions */ | |
| 3366 /* ------------------------------- */ | |
| 3367 | |
| 3368 #if defined (WIN32_NATIVE) && defined (DEBUG_XEMACS) | |
| 3369 #define debugging_breakpoint() DebugBreak () | |
| 3370 #else | |
| 3371 #define debugging_breakpoint() | |
| 3372 #endif | |
| 3373 | |
| 3374 void | |
| 3375 debug_break (void) | |
| 3376 { | |
| 3377 debugging_breakpoint (); | |
| 3378 } | |
| 3379 | |
| 1315 | 3380 #ifdef WIN32_ANY |
| 771 | 3381 |
| 3382 /* Return whether all bytes in the specified memory block can be read. */ | |
| 3383 int | |
| 3384 debug_can_access_memory (void *ptr, Bytecount len) | |
| 3385 { | |
| 3386 return !IsBadReadPtr (ptr, len); | |
| 3387 } | |
| 3388 | |
| 1315 | 3389 #else /* !WIN32_ANY */ |
| 771 | 3390 |
| 3391 /* #### There must be a better way!!!! */ | |
| 3392 | |
| 3393 static JMP_BUF memory_error_jump; | |
| 3394 | |
| 3395 static SIGTYPE | |
| 3396 debug_memory_error (int signum) | |
| 3397 { | |
| 3398 EMACS_REESTABLISH_SIGNAL (signum, debug_memory_error); | |
| 3399 EMACS_UNBLOCK_SIGNAL (signum); | |
| 3400 LONGJMP (memory_error_jump, 1); | |
| 3401 } | |
| 3402 | |
| 3403 /* Return whether all bytes in the specified memory block can be read. */ | |
| 3404 int | |
| 3405 debug_can_access_memory (void *ptr, Bytecount len) | |
| 3406 { | |
| 3407 /* Use volatile to protect variables from being clobbered by longjmp. */ | |
| 3408 SIGTYPE (*volatile old_sigbus) (int); | |
| 3409 SIGTYPE (*volatile old_sigsegv) (int); | |
| 3410 volatile int old_errno = errno; | |
| 3411 volatile int retval = 1; | |
| 3412 | |
| 3413 if (!SETJMP (memory_error_jump)) | |
| 3414 { | |
| 3415 old_sigbus = | |
| 3416 (SIGTYPE (*) (int)) EMACS_SIGNAL (SIGBUS, debug_memory_error); | |
| 3417 old_sigsegv = | |
| 3418 (SIGTYPE (*) (int)) EMACS_SIGNAL (SIGSEGV, debug_memory_error); | |
| 3419 | |
| 3420 if (len > 1) | |
| 3421 /* If we can, try to avoid problems with super-optimizing compilers | |
| 3422 that might decide that memcmp (ptr, ptr, len) can be optimized | |
| 3423 away since its result is always 1. */ | |
| 2367 | 3424 memcmp (ptr, (Rawbyte *) ptr + 1, len - 1); |
| 771 | 3425 else |
| 3426 memcmp (ptr, ptr, len); | |
| 3427 } | |
| 3428 else | |
| 3429 retval = 0; | |
| 3430 EMACS_SIGNAL (SIGBUS, old_sigbus); | |
| 3431 EMACS_SIGNAL (SIGSEGV, old_sigsegv); | |
| 3432 errno = old_errno; | |
| 854 | 3433 |
| 771 | 3434 return retval; |
| 3435 } | |
| 3436 | |
| 1315 | 3437 #endif /* WIN32_ANY */ |
| 771 | 3438 |
| 3439 #ifdef DEBUG_XEMACS | |
| 3440 | |
| 3441 DEFUN ("force-debugging-signal", Fforce_debugging_signal, 0, 1, 0, /* | |
| 3442 Cause XEmacs to enter the debugger. | |
| 3443 On some systems, there may be no way to do this gracefully; if so, | |
| 3444 nothing happens unless ABORT is non-nil, in which case XEmacs will | |
| 2500 | 3445 ABORT() -- a sure-fire way to immediately get back to the debugger, |
| 771 | 3446 but also a sure-fire way to kill XEmacs (and dump core on Unix |
| 3447 systems)! | |
| 3448 */ | |
| 3449 (abort_)) | |
| 3450 { | |
| 3451 debugging_breakpoint (); | |
| 3452 if (!NILP (abort_)) | |
| 2500 | 3453 ABORT (); |
| 771 | 3454 return Qnil; |
| 3455 } | |
| 3456 | |
| 3457 #endif /* DEBUG_XEMACS */ | |
| 3458 | |
| 3459 /* ------------------------------- */ | |
| 3460 /* some helper functions */ | |
| 3461 /* ------------------------------- */ | |
| 3462 | |
| 3463 static void | |
| 3464 ensure_no_quitting_from_now_on (void) | |
| 3465 { | |
| 3466 /* make sure no quitting from now on!! */ | |
| 3467 dont_check_for_quit = 1; | |
| 3468 Vinhibit_quit = Qt; | |
| 3469 Vquit_flag = Qnil; | |
| 3470 } | |
| 3471 | |
| 442 | 3472 #ifdef HAVE_MS_WINDOWS |
| 771 | 3473 static void |
| 3474 pause_so_user_can_read_messages (int allow_further) | |
| 3475 { | |
| 3476 static int already_paused; | |
| 3477 | |
| 1315 | 3478 if (already_paused) |
| 771 | 3479 return; |
| 3480 if (!allow_further) | |
| 3481 already_paused = 1; | |
| 442 | 3482 /* If we displayed a message on the console, then we must allow the |
| 3483 user to see this message. This may be unnecessary, but can't hurt, | |
| 3484 and we can't necessarily check arg; e.g. xemacs --help kills with | |
| 3485 argument 0. */ | |
| 1315 | 3486 if (mswindows_message_outputted && |
| 3487 /* noninteractive, we always show the box. Else, | |
| 3488 do it when there is not yet an initial frame -- in such case, | |
| 3489 XEmacs will just die immediately and we wouldn't see anything. */ | |
| 3490 (noninteractive || NILP (Fselected_frame (Qnil)))) | |
| 771 | 3491 Fmswindows_message_box |
| 3492 (build_msg_string ("Messages outputted. XEmacs is exiting."), | |
| 3493 Qnil, Qnil); | |
| 3494 } | |
| 442 | 3495 #endif |
| 3496 | |
| 826 | 3497 #ifdef WIN32_NATIVE |
| 3498 | |
| 3499 static DWORD CALLBACK | |
| 3500 wait_for_termination_signal (LPVOID handle) | |
| 3501 { | |
| 3502 HANDLE hevent = (HANDLE) handle; | |
| 3503 WaitForSingleObject (hevent, INFINITE); | |
| 3504 ExitProcess (0); | |
| 3505 return 0; /* not reached */ | |
| 3506 } | |
| 3507 | |
| 3508 #endif | |
| 771 | 3509 /* -------------------------------- */ |
| 3510 /* a (more-or-less) normal shutdown */ | |
| 3511 /* -------------------------------- */ | |
| 428 | 3512 |
| 3513 /* Perform an orderly shutdown of XEmacs. Autosave any modified | |
| 3514 buffers, kill any child processes, clean up the terminal modes (if | |
| 3515 we're in the foreground), and other stuff like that. Don't perform | |
| 3516 any redisplay; this may be called when XEmacs is shutting down in | |
| 3517 the background, or after its X connection has died. | |
| 3518 | |
| 3519 If SIG is a signal number, print a message for it. | |
| 3520 | |
| 442 | 3521 This is called by fatal signal handlers and Fkill_emacs. It used to |
| 3522 be called by X protocol error handlers, but instead they now call | |
| 3523 Fkill_emacs. */ | |
| 771 | 3524 |
| 428 | 3525 static void |
| 442 | 3526 shut_down_emacs (int sig, Lisp_Object stuff, int no_auto_save) |
| 428 | 3527 { |
| 3528 /* This function can GC */ | |
| 3529 /* Prevent running of hooks and other non-essential stuff | |
| 3530 from now on. */ | |
| 3531 preparing_for_armageddon = 1; | |
| 3532 | |
| 442 | 3533 ensure_no_quitting_from_now_on (); |
| 428 | 3534 |
| 3535 #ifdef QUANTIFY | |
| 3536 quantify_stop_recording_data (); | |
| 3537 #endif /* QUANTIFY */ | |
| 3538 | |
| 3539 /* This is absolutely the most important thing to do, so make sure | |
| 3540 we do it now, before anything else. We might have crashed and | |
| 3541 be in a weird inconsistent state, and potentially anything could | |
| 3542 set off another protection fault and cause us to bail out | |
| 3543 immediately. */ | |
| 442 | 3544 /* Steve writes the following: |
| 3545 | |
| 3546 [[I'm not removing the code entirely, yet. We have run up against | |
| 428 | 3547 a spate of problems in diagnosing crashes due to crashes within |
| 3548 crashes. It has very definitely been determined that code called | |
| 3549 during auto-saving cannot work if XEmacs crashed inside of GC. | |
| 3550 We already auto-save on an itimer so there cannot be too much | |
| 3551 unsaved stuff around, and if we get better crash reports we might | |
| 442 | 3552 be able to get more problems fixed so I'm disabling this. -slb]] |
| 3553 | |
| 3554 and DISABLES AUTO-SAVING ENTIRELY during crashes! Way way bad idea. | |
| 3555 | |
| 3556 Instead let's just be more intelligent about avoiding crashing | |
| 3557 when possible, esp. nested crashes. | |
| 3558 */ | |
| 3559 if (!no_auto_save) | |
| 3560 Fdo_auto_save (Qt, Qnil); /* do this before anything hazardous */ | |
| 428 | 3561 |
| 3562 fflush (stdout); | |
| 3563 reset_all_consoles (); | |
| 3564 if (sig && sig != SIGTERM) | |
| 3565 { | |
| 442 | 3566 if (sig == -1) |
| 3567 stderr_out ("\nFatal error.\n\n"); | |
| 3568 else | |
| 3569 stderr_out ("\nFatal error (%d).\n\n", sig); | |
| 428 | 3570 stderr_out |
| 3571 ("Your files have been auto-saved.\n" | |
| 1204 | 3572 "Use `M-x recover-session' to recover them.\n" |
| 3573 "\n" | |
| 3574 "Your version of XEmacs was distributed with a PROBLEMS file that may describe\n" | |
| 3575 "your crash, and with luck a workaround. Please check it first, but do report\n" | |
| 3576 "the crash anyway.\n\n" | |
| 428 | 3577 #ifdef INFODOCK |
| 1204 | 3578 "Please report this bug by selecting `Report-Bug' in the InfoDock menu, or\n" |
| 2994 | 3579 "(last resort) by emailing `xemacs-beta@xemacs.org' -- note that this is for\n" |
| 3580 "XEmacs in general, not just Infodock." | |
| 428 | 3581 #else |
| 1204 | 3582 "Please report this bug by invoking M-x report-emacs-bug, or by selecting\n" |
| 3583 "`Send Bug Report' from the Help menu. If that won't work, send ordinary\n" | |
| 2994 | 3584 "email to `xemacs-beta@xemacs.org'." |
| 3585 #endif | |
| 3586 " *MAKE SURE* to include this entire\n" | |
| 3587 "output from this crash, especially including the Lisp backtrace, as well as\n" | |
| 3588 "the XEmacs configuration from M-x describe-installation (or equivalently,\n" | |
| 3589 "the file `Installation' in the top of the build tree).\n" | |
| 1204 | 3590 #ifdef _MSC_VER |
| 3591 "\n" | |
| 3592 "If you are fortunate enough to have some sort of debugging aid installed\n" | |
| 3593 "on your system, for example Visual C++, and you can get a C stack backtrace,\n" | |
| 3594 "*please* include it, as it will make our life far easier.\n" | |
| 3595 "\n" | |
| 3596 #else | |
| 3597 "\n" | |
| 3598 "*Please* try *hard* to obtain a C stack backtrace; without it, we are unlikely\n" | |
| 3599 "to be able to analyze the problem. Locate the core file produced as a result\n" | |
| 3600 "of this crash (often called `core' or `core.<process-id>', and located in\n" | |
| 3601 "the directory in which you started XEmacs or your home directory), and type\n" | |
| 3602 "\n" | |
| 3603 " gdb " | |
| 442 | 3604 #endif |
| 3605 ); | |
| 3606 #ifndef _MSC_VER | |
| 428 | 3607 { |
| 2367 | 3608 const Ibyte *name; |
| 3609 Ibyte *dir = 0; | |
| 428 | 3610 |
| 3611 /* Now try to determine the actual path to the executable, | |
| 3612 to try to make the backtrace-determination process as foolproof | |
| 3613 as possible. */ | |
| 3614 if (STRINGP (Vinvocation_name)) | |
| 2367 | 3615 name = XSTRING_DATA (Vinvocation_name); |
| 428 | 3616 else |
| 2367 | 3617 name = (const Ibyte *) "xemacs"; |
| 428 | 3618 if (STRINGP (Vinvocation_directory)) |
| 2367 | 3619 dir = XSTRING_DATA (Vinvocation_directory); |
| 428 | 3620 if (!dir || dir[0] != '/') |
| 3621 stderr_out ("`which %s`", name); | |
| 2367 | 3622 else if (dir[qxestrlen (dir) - 1] != '/') |
| 428 | 3623 stderr_out ("%s/%s", dir, name); |
| 3624 else | |
| 3625 stderr_out ("%s%s", dir, name); | |
| 3626 } | |
| 3627 stderr_out | |
| 1097 | 3628 (" core\n" |
| 3629 "\n" | |
| 1204 | 3630 "then type `where' at the debugger prompt. No GDB on your system? You may\n" |
| 3631 "have DBX, or XDB, or SDB. (Ask your system administrator if you need help.)\n" | |
| 3632 "If no core file was produced, enable them (often with `ulimit -c unlimited')\n" | |
| 3633 "in case of future recurrance of the crash.\n"); | |
| 442 | 3634 #endif /* _MSC_VER */ |
| 428 | 3635 } |
| 3636 | |
| 3637 stuff_buffered_input (stuff); | |
| 3638 | |
| 3639 kill_buffer_processes (Qnil); | |
| 3640 | |
| 3641 #ifdef CLASH_DETECTION | |
| 3642 unlock_all_files (); | |
| 3643 #endif | |
| 3644 | |
| 3645 #ifdef TOOLTALK | |
| 3646 tt_session_quit (tt_default_session ()); | |
| 3647 #if 0 | |
| 3648 /* The following crashes when built on X11R5 and run on X11R6 */ | |
| 3649 tt_close (); | |
| 3650 #endif | |
| 3651 #endif /* TOOLTALK */ | |
| 3652 } | |
| 3653 | |
| 771 | 3654 /* Dumping apparently isn't supported by versions of GCC >= 2.8. */ |
| 3655 /* The following needs conditionalization on whether either XEmacs or */ | |
| 3656 /* various system shared libraries have been built and linked with */ | |
| 3657 /* GCC >= 2.8. -slb */ | |
| 1303 | 3658 #if defined (GNU_MALLOC) |
| 771 | 3659 static void |
| 2286 | 3660 voodoo_free_hook (void *UNUSED (mem)) |
| 771 | 3661 { |
| 3662 /* Disable all calls to free() when XEmacs is exiting and it doesn't */ | |
| 3663 /* matter. */ | |
| 3664 __free_hook = | |
| 2286 | 3665 #if defined (TYPEOF) && !defined (UNO) |
| 1792 | 3666 /* prototype of __free_hook varies with glibc version */ |
| 1799 | 3667 (TYPEOF (__free_hook)) |
| 440 | 3668 #endif |
| 771 | 3669 voodoo_free_hook; |
| 3670 } | |
| 3671 #endif /* GNU_MALLOC */ | |
| 3672 | |
| 2268 | 3673 DEFUN_NORETURN ("kill-emacs", Fkill_emacs, 0, 1, "P", /* |
| 771 | 3674 Exit the XEmacs job and kill it. Ask for confirmation, without argument. |
| 3675 If ARG is an integer, return ARG as the exit program code. | |
| 3676 If ARG is a string, stuff it as keyboard input. | |
| 3677 | |
| 3678 The value of `kill-emacs-hook', if not void, | |
| 3679 is a list of functions (of no args), | |
| 3680 all of which are called before XEmacs is actually killed. | |
| 428 | 3681 */ |
| 771 | 3682 (arg)) |
| 428 | 3683 { |
| 3684 /* This function can GC */ | |
| 771 | 3685 struct gcpro gcpro1; |
| 3686 | |
| 3687 GCPRO1 (arg); | |
| 3688 | |
| 3689 if (feof (stdin)) | |
| 3690 arg = Qt; | |
| 3691 | |
| 3692 if (!preparing_for_armageddon && !noninteractive) | |
| 3693 run_hook (Qkill_emacs_hook); | |
| 3694 | |
| 3695 ensure_no_quitting_from_now_on (); | |
| 3696 | |
| 3697 if (!preparing_for_armageddon) | |
| 428 | 3698 { |
| 771 | 3699 Lisp_Object concons, nextcons; |
| 3700 | |
| 3701 /* Normally, go ahead and delete all the consoles now. | |
| 3702 Some unmentionably lame window systems (MS Wwwww...... eek, | |
| 3703 I can't even say it) don't properly clean up after themselves, | |
| 3704 and even for those that do, it might be cleaner this way. | |
| 3705 If we're going down, however, we don't do this (might | |
| 3706 be too dangerous), and if we get a crash somewhere within | |
| 3707 this loop, we'll still autosave and won't try this again. */ | |
| 3708 | |
| 3709 LIST_LOOP_DELETING (concons, nextcons, Vconsole_list) | |
| 3710 { | |
| 3711 /* There is very little point in deleting the stream console. | |
| 3712 It uses stdio, which should flush any buffered output and | |
| 3713 something can only go wrong. -slb */ | |
| 3714 /* I changed my mind. There's a stupid hack in close to add | |
| 3715 a trailing newline. */ | |
| 3716 /*if (!CONSOLE_STREAM_P (XCONSOLE (XCAR (concons))))*/ | |
| 3717 delete_console_internal (XCONSOLE (XCAR (concons)), 1, 1, 0); | |
| 3718 } | |
| 428 | 3719 } |
| 3720 | |
| 3721 UNGCPRO; | |
| 3722 | |
| 771 | 3723 #ifdef HAVE_MS_WINDOWS |
| 3724 pause_so_user_can_read_messages (1); | |
| 428 | 3725 #endif |
| 854 | 3726 |
| 771 | 3727 shut_down_emacs (0, STRINGP (arg) ? arg : Qnil, 0); |
| 3728 | |
| 1303 | 3729 #if defined (GNU_MALLOC) |
| 771 | 3730 __free_hook = |
| 2286 | 3731 #if defined (TYPEOF) && !defined (UNO) |
| 1792 | 3732 /* prototype of __free_hook varies with glibc version */ |
| 1799 | 3733 (TYPEOF (__free_hook)) |
| 771 | 3734 #endif |
| 3735 voodoo_free_hook; | |
| 428 | 3736 #endif |
| 771 | 3737 |
| 3738 exit (INTP (arg) ? XINT (arg) : 0); | |
| 2268 | 3739 RETURN_NOT_REACHED (Qnil); |
| 428 | 3740 } |
| 3741 | |
| 771 | 3742 /* -------------------------------- */ |
| 3743 /* abnormal shutdowns: GP faults */ | |
| 3744 /* -------------------------------- */ | |
| 3745 | |
| 814 | 3746 /* This is somewhat ad-hoc ... figure out whether the user is developing |
| 3747 XEmacs, which means (under MS Windows) they have a system debugger | |
| 3748 installed that catches GP faults in any application and lets them open | |
| 3749 up MS Dev Studio and start debugging the application -- similar to | |
| 3750 producing a core dump and then going back with a debugger to investigate | |
| 3751 the core dump, except that the program is still running. When this is | |
| 3752 installed, it's better not to "pause so user gets messages" because the | |
| 3753 debugger will pause anyway; and in case we're currently with a menu | |
| 3754 popped up or somewhere else inside of an internal modal loop, we will | |
| 3755 get wedged when we output the "pause". (It seems that the two modal | |
| 3756 loops will fight each other and the return key will never be passed to | |
| 3757 the "pause" handler so that XEmacs's GPF handler can return, resignal | |
| 3758 the GPF, and properly go into the debugger.) */ | |
| 3759 #if defined (ERROR_CHECK_TYPES) || defined (ERROR_CHECK_TEXT) || defined (ERROR_CHECK_GC) || defined (ERROR_CHECK_STRUCTURES) | |
| 3760 #define USER_IS_DEVELOPING_XEMACS | |
| 3761 #endif | |
| 3762 | |
| 854 | 3763 |
| 771 | 3764 /* Handle bus errors, illegal instruction, etc: actual implementation. */ |
| 3765 static void | |
| 3766 guts_of_fatal_error_signal (int sig) | |
| 428 | 3767 { |
| 771 | 3768 fatal_error_in_progress++; |
| 2367 | 3769 inhibit_non_essential_conversion_operations = 1; |
| 771 | 3770 preparing_for_armageddon = 1; |
| 3771 | |
| 3772 ensure_no_quitting_from_now_on (); | |
| 3773 | |
| 3774 /* Only try auto-saving first time through. If we crash in auto-saving, | |
| 3775 don't do it again. */ | |
| 3776 if (fatal_error_in_progress == 1) | |
| 428 | 3777 { |
| 771 | 3778 Fdo_auto_save (Qt, Qnil); /* do this before anything hazardous */ |
| 3779 /* Do this so that the variable has the same value of 2 regardless of | |
| 3780 whether we made it through auto-saving correctly. */ | |
| 3781 fatal_error_in_progress++; | |
| 428 | 3782 } |
| 771 | 3783 else if (fatal_error_in_progress == 2) |
| 3784 stderr_out ("WARNING: Unable to auto-save your files properly.\n" | |
| 3785 "Some or all may in fact have been auto-saved.\n" | |
| 3786 "\n"); | |
| 3787 | |
| 3788 /* Now, reset our signal handler, so the next time, we just die. | |
| 3789 Don't do this before auto-saving. */ | |
| 3790 if (sig >= 0) | |
| 3791 EMACS_SIGNAL (sig, SIG_DFL); | |
| 3792 | |
| 3793 /* Keep in mind that there's more than one signal that we can crash | |
| 3794 on. */ | |
| 3795 /* If fatal error occurs in code below, avoid infinite recursion. */ | |
| 3796 if (fatal_error_in_progress <= 2) | |
| 3797 { | |
| 3798 shut_down_emacs (sig, Qnil, 1); | |
| 3799 stderr_out ("\nLisp backtrace follows:\n\n"); | |
| 3800 debug_backtrace (); | |
| 3801 # if 0 /* This is evil, rarely useful, and causes grief in some cases. */ | |
| 3802 /* Check for Sun-style stack printing via /proc */ | |
| 3803 { | |
| 2367 | 3804 const Ascbyte *pstack = "/usr/proc/bin/pstack"; |
| 771 | 3805 if (access (pstack, X_OK) == 0) |
| 3806 { | |
| 2367 | 3807 Ascbyte buf[100]; |
| 771 | 3808 stderr_out ("\nC backtrace follows:\n" |
| 3809 "(A real debugger may provide better information)\n\n"); | |
| 2367 | 3810 sprintf (buf, "%s %d >&2", pstack, (int) getpid()); |
| 771 | 3811 system (buf); |
| 3812 } | |
| 3813 } | |
| 3814 # endif | |
| 814 | 3815 #if defined (HAVE_MS_WINDOWS) && !defined (USER_IS_DEVELOPING_XEMACS) |
| 771 | 3816 pause_so_user_can_read_messages (0); |
| 3817 #endif | |
| 3818 } | |
| 428 | 3819 } |
| 3820 | |
| 771 | 3821 /* This is called when a fatal signal (SIGBUS aka "bus error", SIGSEGV aka |
| 3822 "segmentation violation", SIGILL aka "illegal instruction", and many | |
| 3823 others) is sent to the program. This generally happens under Unix, | |
| 3824 not MS Windows. */ | |
| 3825 SIGTYPE | |
| 3826 fatal_error_signal (int sig) | |
| 428 | 3827 { |
| 771 | 3828 /* Unblock the signal so that if the same signal gets sent in the |
| 3829 code below, we avoid a deadlock. */ | |
| 3830 EMACS_UNBLOCK_SIGNAL (sig); | |
| 3831 | |
| 3832 guts_of_fatal_error_signal (sig); | |
| 3833 | |
| 3092 | 3834 #ifdef NEW_GC |
| 3835 /* This time the signal will really be fatal. To be able to debug | |
| 3836 SIGSEGV and SIGBUS also during write barrier, send SIGABRT. */ | |
| 3837 #ifdef WIN32_NATIVE | |
| 3838 if (sig == SIGSEGV) | |
| 3839 raise (SIGABRT); | |
| 3840 else | |
| 3841 raise (sig); | |
| 3842 #else | |
| 3843 if ((sig == SIGSEGV) || (sig == SIGBUS)) | |
| 3844 kill (qxe_getpid (), SIGABRT); | |
| 3845 else | |
| 3846 kill (qxe_getpid (), sig); | |
| 3847 #endif | |
| 3848 #else /* not NEW_GC */ | |
| 771 | 3849 /* Signal the same code; this time it will really be fatal. */ |
| 3850 #ifdef WIN32_NATIVE | |
| 3851 raise (sig); | |
| 3852 #else | |
| 3853 kill (qxe_getpid (), sig); | |
| 3854 #endif | |
| 3092 | 3855 #endif /* not NEW_GC */ |
| 771 | 3856 SIGRETURN; |
| 428 | 3857 } |
| 3858 | |
| 771 | 3859 #ifdef _MSC_VER |
| 3860 | |
| 3861 #define STATUS_ASSERTION_FAILURE 0xE0000001 | |
| 3862 | |
| 3863 static DWORD | |
| 3864 mswindows_handle_hardware_exceptions_1 (void) | |
| 428 | 3865 { |
| 2367 | 3866 inhibit_non_essential_conversion_operations = 1; |
| 793 | 3867 preparing_for_armageddon = 1; |
| 814 | 3868 #if !defined (USER_IS_DEVELOPING_XEMACS) |
| 771 | 3869 pause_so_user_can_read_messages (0); |
| 814 | 3870 #endif |
| 771 | 3871 return EXCEPTION_EXECUTE_HANDLER; |
| 428 | 3872 } |
| 3873 | |
| 771 | 3874 /* This is called under MS Windows when an exception (this encompasses both |
| 3875 user-defined exceptions and hardware exceptions such as GP faults aka | |
| 3876 SIGBUS or SIGSEGV) is triggered. */ | |
| 3877 | |
| 3878 static DWORD | |
| 3879 mswindows_handle_hardware_exceptions (DWORD code) | |
| 428 | 3880 { |
| 771 | 3881 if (code != STATUS_ACCESS_VIOLATION && code != STATUS_ILLEGAL_INSTRUCTION |
| 3882 && code != STATUS_PRIVILEGED_INSTRUCTION | |
| 3883 && code != STATUS_DATATYPE_MISALIGNMENT | |
| 3884 && code != STATUS_ASSERTION_FAILURE) | |
| 3885 return EXCEPTION_CONTINUE_SEARCH; | |
| 3886 | |
| 3887 /* I don't know if this filter is still wrapped in the outer __try, but | |
| 3888 it doesn't hurt to have another one, and it lets us control more | |
| 3889 exactly what we really want to do in such a situation. What we do is | |
| 3890 pause, if we haven't already done so, so that the user can see what's | |
| 3891 output. This is critical because otherwise the output is gone. */ | |
| 3892 __try | |
| 3893 { | |
| 3894 guts_of_fatal_error_signal (-1); | |
| 3895 } | |
| 3896 /* VC++ documentation says that | |
| 3897 GetExceptionCode() cannot be called inside the filter itself. */ | |
| 3898 | |
| 3899 /* __except (mswindows_handle_hardware_exceptions (GetExceptionCode ())) {} | |
| 3900 | |
| 3901 The line above is original. Unfortunately, when an error is tripped | |
| 3902 inside of the handler (e.g. during Fbacktrace()), and the handler for | |
| 3903 the handler is invoked, it correctly notices that something is amiss | |
| 3904 and it should just return -- but it returns EXCEPTION_CONTINUE_SEARCH, | |
| 3905 which causes the debugger to be invoked debugging the handler code in | |
| 3906 this function -- and WITH THE STACK UNWOUND so that you see main() | |
| 3907 calling mswindows_handle_hardware_exceptions(), calling Fbacktrace(), | |
| 3908 and a crash a couple of frames in -- AND NO SIGN OF THE ORIGINAL CRASH! | |
| 3909 | |
| 3910 There's some real weirdness going on in the stack handling -- unlike | |
| 3911 in Unix, where further crashes just keep adding to the stack, it seems | |
| 3912 that under the structured-exception-handling, the stack can actually | |
| 3913 bounce back and forth between the full stack at the location of the | |
| 3914 exception and the unwound stack at the place where the __try clause was | |
| 3915 established. I don't completely understand it. What I do know is that | |
| 3916 returning EXCEPTION_EXECUTE_HANDLER on nested crash has the effect of | |
| 3917 aborting execution of the handler and going back to the outer filter | |
| 3918 function, which returns EXCEPTION_CONTINUE_SEARCH and everything is | |
| 3919 hunky-dorey -- your debugger sees a crash at the right location with | |
| 3920 the right stack. | |
| 3921 | |
| 3922 I'm leaving in the trickier Unix-like code in the handler; someone who | |
| 3923 understands better than me how the stack works in these handlers could | |
| 3924 fix it up more. As it is, it works pretty well, so I'm not likely to | |
| 3925 touch it more. --ben | |
| 3926 */ | |
| 3927 | |
| 3928 __except (mswindows_handle_hardware_exceptions_1 ()) {} | |
| 3929 | |
| 3930 /* pretend we didn't handle this, so that the debugger is invoked and/or | |
| 3931 the normal GPF box appears. */ | |
| 3932 return EXCEPTION_CONTINUE_SEARCH; | |
| 428 | 3933 } |
| 3934 | |
| 771 | 3935 #endif /* _MSC_VER */ |
| 3936 | |
| 3937 /* -------------------------------------- */ | |
| 3938 /* abnormal shutdowns: assertion failures */ | |
| 3939 /* -------------------------------------- */ | |
| 428 | 3940 |
| 3941 /* This flag is useful to define if you're under a debugger; this way, you | |
| 3942 can put a breakpoint of assert_failed() and debug multiple problems | |
| 3943 in one session without having to recompile. */ | |
| 3944 /* #define ASSERTIONS_DONT_ABORT */ | |
| 3945 | |
| 3946 /* This highly dubious kludge ... shut up Jamie, I'm tired of your slagging. */ | |
| 3947 | |
| 771 | 3948 /* Nonzero if handling an assertion failure. (Bumped by one each time |
| 3949 we recursively hit such a failure.) */ | |
| 442 | 3950 static int in_assert_failed; |
| 771 | 3951 |
| 2367 | 3952 static const Ascbyte *assert_failed_file; |
| 442 | 3953 static int assert_failed_line; |
| 2367 | 3954 static const Ascbyte *assert_failed_expr; |
| 442 | 3955 |
| 3956 #ifdef fprintf | |
| 3957 #undef fprintf | |
| 3958 #endif | |
| 3959 | |
| 2500 | 3960 /* This is called when an assert() fails or when ABORT() is called -- both |
| 771 | 3961 of those are defined in the preprocessor to an expansion involving |
| 3962 assert_failed(). */ | |
| 442 | 3963 void |
| 2367 | 3964 assert_failed (const Ascbyte *file, int line, const Ascbyte *expr) |
| 428 | 3965 { |
| 442 | 3966 /* If we're already crashing, let's not crash again. This might be |
| 3967 critical to getting auto-saving working properly. */ | |
| 3968 if (fatal_error_in_progress) | |
| 3969 return; | |
| 3970 | |
| 3971 /* We are extremely paranoid so we sensibly deal with recursive | |
| 3972 assertion failures. */ | |
| 3973 in_assert_failed++; | |
| 2367 | 3974 inhibit_non_essential_conversion_operations = 1; |
| 442 | 3975 |
| 3976 if (in_assert_failed >= 4) | |
| 3977 _exit (-1); | |
| 3978 else if (in_assert_failed == 3) | |
| 3979 { | |
| 771 | 3980 debugging_breakpoint (); |
| 442 | 3981 _exit (-1); |
| 3982 } | |
| 3983 else if (in_assert_failed == 2) | |
| 3984 { | |
| 771 | 3985 /* Ultra-paranoia. stderr_out() tries very hard not to do |
| 3986 anything during assertion failures that might trigger more | |
| 3987 failures; but we might have messed up somewhere. fprintf was | |
| 3988 undeffed above, in case it was encapsulated. */ | |
| 442 | 3989 fprintf (stderr, |
| 3990 "Fatal error: recursive assertion failure, " | |
| 3991 "file %s, line %d, %s\n", | |
| 3992 file, line, expr); | |
| 3993 fprintf (stderr, | |
| 3994 "Original assertion failure: file %s, line %d, %s\n", | |
| 3995 assert_failed_file, assert_failed_line, assert_failed_expr); | |
| 3996 } | |
| 3997 else | |
| 3998 { | |
| 3999 assert_failed_file = file; | |
| 4000 assert_failed_line = line; | |
| 4001 assert_failed_expr = expr; | |
| 4002 | |
| 771 | 4003 stderr_out ("\nFatal error: assertion failed, file %s, line %d, %s\n", |
| 4004 file, line, expr); | |
| 442 | 4005 } |
| 4006 | |
| 771 | 4007 /* Enable the following if you want a breakpoint right away to the |
| 4008 debugger, without the whole shutdown processing first. This can be | |
| 4009 useful if you're afraid the shutdown processing will modify state that | |
| 4010 you're trying to debug (generally fairly unlikely); but you then don't | |
| 4011 get the auto-save behavior, which may be extremely important if you | |
| 4012 were in the middle of doing something */ | |
| 4013 /* debugging_breakpoint (); */ | |
| 442 | 4014 #if !defined (ASSERTIONS_DONT_ABORT) |
| 1346 | 4015 #if defined (_MSC_VER) || defined (CYGWIN) |
| 4016 /* In VC++, calling abort() directly just seems to exit, in a way we can't | |
| 1303 | 4017 trap. (#### The docs say it does raise (SIGABRT), which we should be |
| 771 | 4018 able to trap. Perhaps we're messing up somewhere? Or perhaps MS is |
| 4019 messed up.) | |
| 4020 | |
| 4021 So, instead we cause an exception and enter into the structured | |
| 4022 exception-handling mechanism, which is just like what happens when a | |
| 4023 GPF occurs, and is cleaner anyway. (If we entered into one of the | |
| 4024 signal handlers, a crash in there would enter anyway into the | |
| 4025 structured exception stuff, and you'd get some weird mixture. Cleaner | |
| 4026 to keep it all in the expected way.) | |
| 4027 */ | |
| 4028 /* Either of the following work in terms of causing an exception. The | |
| 4029 second one looks cleaner but you get an odd message about "Unknown | |
| 4030 software exception ..." without the obvious "OK to terminate", "Cancel | |
| 4031 to debug"; instead, you just get OK/Cancel, which in fact do those | |
| 4032 same things. */ | |
| 1346 | 4033 /* In Cygwin, abort() doesn't get trapped properly in gdb but seg faults |
| 4034 do, so we resort to the same trick. */ | |
| 771 | 4035 * ((int *) 0) = 666; |
| 4036 /* RaiseException (STATUS_ASSERTION_FAILURE, EXCEPTION_NONCONTINUABLE, 0, | |
| 4037 0); */ | |
| 4038 #else | |
| 4039 really_abort (); | |
| 1346 | 4040 #endif /* defined (_MSC_VER) || defined (CYGWIN) */ |
| 771 | 4041 #endif /* !defined (ASSERTIONS_DONT_ABORT) */ |
| 2367 | 4042 inhibit_non_essential_conversion_operations = 0; |
| 442 | 4043 in_assert_failed = 0; |
| 428 | 4044 } |
| 4045 | |
| 771 | 4046 /* -------------------------------------- */ |
| 4047 /* low-memory notification */ | |
| 4048 /* -------------------------------------- */ | |
| 4049 | |
| 4050 #ifdef SIGDANGER | |
| 4051 | |
| 4052 /* Handler for SIGDANGER. */ | |
| 4053 SIGTYPE | |
| 4054 memory_warning_signal (int sig) | |
| 4055 { | |
| 4056 /* #### bad bad bad; this function shouldn't do anything except | |
| 4057 set a flag, or weird corruption could happen. */ | |
| 4058 EMACS_SIGNAL (sig, memory_warning_signal); | |
| 4059 | |
| 4060 malloc_warning | |
| 4061 (GETTEXT ("Operating system warns that virtual memory is running low.\n")); | |
| 4062 | |
| 4063 /* It might be unsafe to call do_auto_save now. */ | |
| 4064 force_auto_save_soon (); | |
| 4065 } | |
| 4066 #endif /* SIGDANGER */ | |
| 4067 | |
| 4068 | |
| 4069 /************************************************************************/ | |
| 4070 /* Miscellaneous */ | |
| 4071 /************************************************************************/ | |
| 4072 | |
| 4073 DEFUN ("noninteractive", Fnoninteractive, 0, 0, 0, /* | |
| 4074 Non-nil return value means XEmacs is running without interactive terminal. | |
| 528 | 4075 */ |
| 771 | 4076 ()) |
| 528 | 4077 { |
| 771 | 4078 return noninteractive ? Qt : Qnil; |
| 528 | 4079 } |
| 4080 | |
| 428 | 4081 #ifdef QUANTIFY |
| 4082 DEFUN ("quantify-start-recording-data", Fquantify_start_recording_data, | |
| 4083 0, 0, "", /* | |
| 4084 Start recording Quantify data. | |
| 4085 */ | |
| 4086 ()) | |
| 4087 { | |
| 4088 quantify_start_recording_data (); | |
| 4089 return Qnil; | |
| 4090 } | |
| 4091 | |
| 4092 DEFUN ("quantify-stop-recording-data", Fquantify_stop_recording_data, | |
| 4093 0, 0, "", /* | |
| 4094 Stop recording Quantify data. | |
| 4095 */ | |
| 4096 ()) | |
| 4097 { | |
| 4098 quantify_stop_recording_data (); | |
| 4099 return Qnil; | |
| 4100 } | |
| 4101 | |
| 4102 DEFUN ("quantify-clear-data", Fquantify_clear_data, 0, 0, "", /* | |
| 4103 Clear all Quantify data. | |
| 4104 */ | |
| 4105 ()) | |
| 4106 { | |
| 4107 quantify_clear_data (); | |
| 4108 return Qnil; | |
| 4109 } | |
| 4110 #endif /* QUANTIFY */ | |
| 4111 | |
| 4112 void | |
| 4113 syms_of_emacs (void) | |
| 4114 { | |
| 4115 DEFSUBR (Fdump_emacs); | |
| 4116 | |
| 4117 DEFSUBR (Frun_emacs_from_temacs); | |
| 4118 DEFSUBR (Frunning_temacs_p); | |
| 1315 | 4119 DEFSUBR (Femacs_run_status); |
| 428 | 4120 DEFSUBR (Finvocation_name); |
| 4121 DEFSUBR (Finvocation_directory); | |
| 4122 DEFSUBR (Fkill_emacs); | |
| 4123 DEFSUBR (Fnoninteractive); | |
| 4124 | |
| 528 | 4125 #ifdef DEBUG_XEMACS |
| 4126 DEFSUBR (Fforce_debugging_signal); | |
| 4127 #endif | |
| 4128 | |
| 428 | 4129 #ifdef QUANTIFY |
| 4130 DEFSUBR (Fquantify_start_recording_data); | |
| 4131 DEFSUBR (Fquantify_stop_recording_data); | |
| 4132 DEFSUBR (Fquantify_clear_data); | |
| 4133 #endif /* QUANTIFY */ | |
| 4134 | |
| 563 | 4135 DEFSYMBOL (Qkill_emacs_hook); |
| 4136 DEFSYMBOL (Qsave_buffers_kill_emacs); | |
| 1315 | 4137 |
| 4138 DEFSYMBOL (Qtemacs); | |
| 4139 DEFSYMBOL (Qdumping); | |
| 4140 DEFSYMBOL (Qrestarted); | |
| 4141 DEFSYMBOL (Qpdump); | |
| 4142 DEFSYMBOL (Qbatch); | |
| 428 | 4143 } |
| 4144 | |
| 776 | 4145 /* Yuck! These variables may get set from command-line options when |
| 4146 dumping; if we don't clear them, they will still be on once the dumped | |
| 4147 XEmacs reloads. (not an issue with pdump, as we kludge around this in | |
| 4148 main_1().) */ | |
| 4149 | |
| 4150 void | |
| 4151 zero_out_command_line_status_vars (void) | |
| 4152 { | |
| 4153 vanilla_inhibiting = 0; | |
| 4154 inhibit_early_packages = 0; | |
| 4155 inhibit_all_packages = 0; | |
| 4156 inhibit_autoloads = 0; | |
| 4157 debug_paths = 0; | |
| 4158 #ifndef INHIBIT_SITE_LISP | |
| 4159 inhibit_site_lisp = 0; | |
| 4160 #else | |
| 4161 inhibit_site_lisp = 1; | |
| 4162 #endif | |
| 4163 #ifndef INHIBIT_SITE_MODULES | |
| 4164 inhibit_site_modules = 0; | |
| 4165 #else | |
| 4166 inhibit_site_modules = 1; | |
| 4167 #endif | |
| 4168 } | |
| 4169 | |
| 428 | 4170 void |
| 4171 vars_of_emacs (void) | |
| 4172 { | |
| 4173 DEFVAR_BOOL ("suppress-early-error-handler-backtrace", | |
| 4174 &suppress_early_error_handler_backtrace /* | |
| 4175 Non-nil means early error handler shouldn't print a backtrace. | |
| 4176 */ ); | |
| 4177 | |
| 4178 DEFVAR_LISP ("command-line-args", &Vcommand_line_args /* | |
| 4179 Args passed by shell to XEmacs, as a list of strings. | |
| 4180 */ ); | |
| 4181 | |
| 4182 DEFVAR_LISP ("invocation-name", &Vinvocation_name /* | |
| 4183 The program name that was used to run XEmacs. | |
| 4184 Any directory names are omitted. | |
| 4185 */ ); | |
| 4186 | |
| 4187 DEFVAR_LISP ("invocation-directory", &Vinvocation_directory /* | |
| 4188 The directory in which the XEmacs executable was found, to run it. | |
| 4189 The value is simply the program name if that directory's name is not known. | |
| 4190 */ ); | |
| 4191 | |
| 4192 DEFVAR_LISP ("invocation-path", &Vinvocation_path /* | |
| 4193 The path in which the XEmacs executable was found, to run it. | |
| 4194 The value is simply the value of environment variable PATH on startup | |
| 4195 if XEmacs was found there. | |
| 4196 */ ); | |
| 4197 | |
| 4198 #if 0 /* FSFmacs */ | |
| 776 | 4199 xxDEFVAR_LISP ("installation-directory", &Vinstallation_directory /* |
| 4200 A directory within which to look for the `lib-src' and `etc' directories. | |
| 4201 This is non-nil when we can't find those directories in their standard | |
| 4202 installed locations, but we can find them ear where the XEmacs executable | |
| 4203 was found. | |
| 4204 */ ); | |
| 428 | 4205 #endif |
| 4206 | |
| 4207 DEFVAR_LISP ("system-type", &Vsystem_type /* | |
| 4208 Symbol indicating type of operating system you are using. | |
| 4209 */ ); | |
| 4210 Vsystem_type = intern (SYSTEM_TYPE); | |
| 771 | 4211 Fprovide (Vsystem_type); |
| 428 | 4212 |
| 4213 #ifndef EMACS_CONFIGURATION | |
| 4214 # define EMACS_CONFIGURATION "UNKNOWN" | |
| 4215 #endif | |
| 4216 DEFVAR_LISP ("system-configuration", &Vsystem_configuration /* | |
| 4217 String naming the configuration XEmacs was built for. | |
| 4218 */ ); | |
| 4219 Vsystem_configuration = build_string (EMACS_CONFIGURATION); | |
| 4220 | |
| 4221 #ifndef EMACS_CONFIG_OPTIONS | |
| 4222 # define EMACS_CONFIG_OPTIONS "UNKNOWN" | |
| 4223 #endif | |
| 4224 DEFVAR_LISP ("system-configuration-options", &Vsystem_configuration_options /* | |
| 4225 String containing the configuration options XEmacs was built with. | |
| 4226 */ ); | |
| 4227 Vsystem_configuration_options = build_string (EMACS_CONFIG_OPTIONS); | |
| 4228 | |
| 4229 DEFVAR_LISP ("emacs-major-version", &Vemacs_major_version /* | |
| 4230 Major version number of this version of Emacs, as an integer. | |
| 4231 Warning: this variable did not exist in Emacs versions earlier than: | |
| 4232 FSF Emacs: 19.23 | |
| 4233 XEmacs: 19.10 | |
| 4234 */ ); | |
| 4235 Vemacs_major_version = make_int (EMACS_MAJOR_VERSION); | |
| 4236 | |
| 4237 DEFVAR_LISP ("emacs-minor-version", &Vemacs_minor_version /* | |
| 4238 Minor version number of this version of Emacs, as an integer. | |
| 4239 Warning: this variable did not exist in Emacs versions earlier than: | |
| 4240 FSF Emacs: 19.23 | |
| 4241 XEmacs: 19.10 | |
| 4242 */ ); | |
| 4243 Vemacs_minor_version = make_int (EMACS_MINOR_VERSION); | |
| 4244 | |
| 4245 DEFVAR_LISP ("emacs-patch-level", &Vemacs_patch_level /* | |
| 4246 The patch level of this version of Emacs, as an integer. | |
| 4247 The value is non-nil if this version of XEmacs is part of a series of | |
| 4248 stable XEmacsen, but has bug fixes applied. | |
| 4249 Warning: this variable does not exist in FSF Emacs or in XEmacs versions | |
| 4250 earlier than 21.1.1 | |
| 4251 */ ); | |
| 4252 #ifdef EMACS_PATCH_LEVEL | |
| 4253 Vemacs_patch_level = make_int (EMACS_PATCH_LEVEL); | |
| 4254 #else | |
| 4255 Vemacs_patch_level = Qnil; | |
| 4256 #endif | |
| 4257 | |
| 4258 DEFVAR_LISP ("emacs-beta-version", &Vemacs_beta_version /* | |
| 4259 Beta number of this version of Emacs, as an integer. | |
| 4260 The value is nil if this is an officially released version of XEmacs. | |
| 4261 Warning: this variable does not exist in FSF Emacs or in XEmacs versions | |
| 4262 earlier than 20.3. | |
| 4263 */ ); | |
| 4264 #ifdef EMACS_BETA_VERSION | |
| 4265 Vemacs_beta_version = make_int (EMACS_BETA_VERSION); | |
| 4266 #else | |
| 4267 Vemacs_beta_version = Qnil; | |
| 4268 #endif | |
| 4269 | |
| 4270 #ifdef INFODOCK | |
| 4271 DEFVAR_LISP ("infodock-major-version", &Vinfodock_major_version /* | |
| 4272 Major version number of this InfoDock release. | |
| 4273 */ ); | |
| 4274 Vinfodock_major_version = make_int (INFODOCK_MAJOR_VERSION); | |
| 4275 | |
| 4276 DEFVAR_LISP ("infodock-minor-version", &Vinfodock_minor_version /* | |
| 4277 Minor version number of this InfoDock release. | |
| 4278 */ ); | |
| 4279 Vinfodock_minor_version = make_int (INFODOCK_MINOR_VERSION); | |
| 4280 | |
| 4281 DEFVAR_LISP ("infodock-build-version", &Vinfodock_build_version /* | |
| 4282 Build version of this InfoDock release. | |
| 4283 */ ); | |
| 4284 Vinfodock_build_version = make_int (INFODOCK_BUILD_VERSION); | |
| 4285 #endif | |
| 4286 | |
| 4287 DEFVAR_LISP ("xemacs-codename", &Vxemacs_codename /* | |
| 4288 Codename of this version of Emacs (a string). | |
| 4289 */ ); | |
| 4290 #ifndef XEMACS_CODENAME | |
| 4291 #define XEMACS_CODENAME "Noname" | |
| 4292 #endif | |
| 4293 Vxemacs_codename = build_string (XEMACS_CODENAME); | |
| 4294 | |
| 975 | 4295 DEFVAR_LISP ("xemacs-extra-name", &Vxemacs_extra_name /* |
| 2602 | 4296 Arbitrary string to place in the version string after the codename. |
| 4297 | |
| 4298 Appropriate surrounding whitespace will be added, but typically looks best | |
| 4299 if enclosed in parentheses. | |
| 4300 | |
|
4419
eb82fbb675ea
Use Mercurial changeset hash to identify build version.
Mike Sperber <sperber@deinprogramm.de>
parents:
4380
diff
changeset
|
4301 A standard use is to indicate the topmost hash id of the Mercurial |
|
eb82fbb675ea
Use Mercurial changeset hash to identify build version.
Mike Sperber <sperber@deinprogramm.de>
parents:
4380
diff
changeset
|
4302 changeset from which XEmacs was compiled. Developers may also use it |
|
eb82fbb675ea
Use Mercurial changeset hash to identify build version.
Mike Sperber <sperber@deinprogramm.de>
parents:
4380
diff
changeset
|
4303 to indicate particular branches, etc. |
| 975 | 4304 */ ); |
| 4305 #ifdef XEMACS_EXTRA_NAME | |
| 4306 Vxemacs_extra_name = build_string (XEMACS_EXTRA_NAME); | |
| 4307 #endif | |
| 4308 | |
| 2602 | 4309 DEFVAR_LISP ("xemacs-release-date", &Vxemacs_release_date /* |
| 4310 ISO 8601 format date string giving the date of latest release in series. | |
| 4311 | |
| 4312 The time may optionally be given. The time zone may not be given, and | |
| 4313 is (implicitly) UTC. Currently not included in the version string. | |
| 4314 */ ); | |
| 4315 #ifndef XEMACS_RELEASE_DATE | |
| 4316 #define XEMACS_RELEASE_DATE "2005-02-18 (defaulted in emacs.c)" | |
| 4317 #endif | |
| 4318 Vxemacs_release_date = build_string (XEMACS_RELEASE_DATE); | |
| 4319 | |
| 442 | 4320 /* Lisp variables which contain command line flags. |
| 4321 | |
| 4322 The portable dumper stomps on these; they must be saved and restored | |
| 4323 if they are processed before the call to pdump_load() in main_1(). | |
| 4324 */ | |
| 428 | 4325 DEFVAR_BOOL ("noninteractive", &noninteractive1 /* |
| 4326 Non-nil means XEmacs is running without interactive terminal. | |
| 4327 */ ); | |
| 4328 | |
| 776 | 4329 DEFVAR_BOOL ("vanilla-inhibiting", &vanilla_inhibiting /* |
| 4330 Set to non-nil when the user-init and site-start files should not be loaded. | |
| 4331 */ ); | |
| 4332 | |
| 428 | 4333 DEFVAR_BOOL ("inhibit-early-packages", &inhibit_early_packages /* |
| 2602 | 4334 Set to non-nil when the early packages should be ignored at startup. |
| 4335 Early package directories will not be added to `load-path', nor set up as | |
| 4336 autoloads, nothing. | |
| 428 | 4337 */ ); |
| 4338 | |
| 776 | 4339 DEFVAR_BOOL ("inhibit-all-packages", &inhibit_all_packages /* |
| 2602 | 4340 Set to non-nil when all packages should be ignored at startup. |
| 4341 Package directories will not be added to `load-path', nor set up as | |
| 776 | 4342 autoloads, nothing. |
| 4343 */ ); | |
| 4344 | |
| 428 | 4345 DEFVAR_BOOL ("inhibit-autoloads", &inhibit_autoloads /* |
| 4346 Set to non-nil when autoloads should not be loaded at startup. | |
| 4347 */ ); | |
| 4348 | |
| 4349 DEFVAR_BOOL ("debug-paths", &debug_paths /* | |
| 4350 Set to non-nil when debug information about paths should be printed. | |
| 4351 */ ); | |
| 4352 | |
| 4353 DEFVAR_BOOL ("inhibit-site-lisp", &inhibit_site_lisp /* | |
| 4354 Set to non-nil when the site-lisp should not be searched at startup. | |
| 4355 */ ); | |
| 4356 #ifdef INHIBIT_SITE_LISP | |
| 4357 inhibit_site_lisp = 1; | |
| 4358 #endif | |
| 4359 | |
| 4360 DEFVAR_BOOL ("inhibit-site-modules", &inhibit_site_modules /* | |
| 4361 Set to non-nil when site-modules should not be searched at startup. | |
| 4362 */ ); | |
| 4363 #ifdef INHIBIT_SITE_MODULES | |
| 4364 inhibit_site_modules = 1; | |
| 4365 #endif | |
| 4366 | |
| 4367 DEFVAR_INT ("emacs-priority", &emacs_priority /* | |
| 4368 Priority for XEmacs to run at. | |
| 4369 This value is effective only if set before XEmacs is dumped, | |
| 4370 and only if the XEmacs executable is installed with setuid to permit | |
| 4371 it to change priority. (XEmacs sets its uid back to the real uid.) | |
| 4372 Currently, you need to define SET_EMACS_PRIORITY in `config.h' | |
| 4373 before you compile XEmacs, to enable the code for this feature. | |
| 4374 */ ); | |
| 4375 emacs_priority = 0; | |
| 4376 | |
| 4377 DEFVAR_CONST_LISP ("internal-error-checking", &Vinternal_error_checking /* | |
| 4378 Internal error checking built-in into this instance of XEmacs. | |
| 4379 This is a list of symbols, initialized at build-time. Legal symbols | |
| 4380 are: | |
| 4381 | |
| 4382 extents - check extents prior to each extent change; | |
| 800 | 4383 types - check types strictly; |
| 428 | 4384 malloc - check operation of malloc; |
| 4385 gc - check garbage collection; | |
| 800 | 4386 text - check text and buffer positions; |
| 4387 display - check redisplay structure consistency; | |
| 4388 glyphs - check glyph structure consistency; | |
| 4389 byte-code - check byte-code consistency;. | |
| 4390 structures - check other structure consistency. | |
| 442 | 4391 |
| 4392 quick-build - user has requested the "quick-build" configure option. | |
| 428 | 4393 */ ); |
| 4394 Vinternal_error_checking = Qnil; | |
| 4395 #ifdef ERROR_CHECK_EXTENTS | |
| 4396 Vinternal_error_checking = Fcons (intern ("extents"), | |
| 4397 Vinternal_error_checking); | |
| 4398 #endif | |
| 800 | 4399 #ifdef ERROR_CHECK_TYPES |
| 4400 Vinternal_error_checking = Fcons (intern ("types"), | |
| 428 | 4401 Vinternal_error_checking); |
| 4402 #endif | |
| 4403 #ifdef ERROR_CHECK_MALLOC | |
| 4404 Vinternal_error_checking = Fcons (intern ("malloc"), | |
| 4405 Vinternal_error_checking); | |
| 4406 #endif | |
| 4407 #ifdef ERROR_CHECK_GC | |
| 4408 Vinternal_error_checking = Fcons (intern ("gc"), | |
| 4409 Vinternal_error_checking); | |
| 4410 #endif | |
| 800 | 4411 #ifdef ERROR_CHECK_TEXT |
| 4412 Vinternal_error_checking = Fcons (intern ("text"), | |
| 4413 Vinternal_error_checking); | |
| 4414 #endif | |
| 4415 #ifdef ERROR_CHECK_DISPLAY | |
| 4416 Vinternal_error_checking = Fcons (intern ("display"), | |
| 4417 Vinternal_error_checking); | |
| 4418 #endif | |
| 4419 #ifdef ERROR_CHECK_GLYPHS | |
| 4420 Vinternal_error_checking = Fcons (intern ("glyphs"), | |
| 4421 Vinternal_error_checking); | |
| 4422 #endif | |
| 4423 #ifdef ERROR_CHECK_BYTE_CODE | |
| 4424 Vinternal_error_checking = Fcons (intern ("byte-code"), | |
| 4425 Vinternal_error_checking); | |
| 4426 #endif | |
| 4427 #ifdef ERROR_CHECK_STRUCTURES | |
| 4428 Vinternal_error_checking = Fcons (intern ("structures"), | |
| 428 | 4429 Vinternal_error_checking); |
| 4430 #endif | |
| 442 | 4431 #ifdef QUICK_BUILD |
| 4432 Vinternal_error_checking = Fcons (intern ("quick-build"), | |
| 4433 Vinternal_error_checking); | |
| 4434 #endif | |
| 428 | 4435 |
| 438 | 4436 DEFVAR_CONST_LISP ("mail-lock-methods", &Vmail_lock_methods /* |
| 4437 Mail spool locking methods supported by this instance of XEmacs. | |
| 4438 This is a list of symbols. Each of the symbols is one of the | |
| 4439 following: dot, lockf, flock, locking, mmdf. | |
| 4440 */ ); | |
| 4441 { | |
| 4442 Vmail_lock_methods = Qnil; | |
| 4443 Vmail_lock_methods = Fcons (intern ("dot"), Vmail_lock_methods); | |
| 4444 #ifdef HAVE_LOCKF | |
| 4445 Vmail_lock_methods = Fcons (intern ("lockf"), Vmail_lock_methods); | |
| 4446 #endif | |
| 4447 #ifdef HAVE_FLOCK | |
| 4448 Vmail_lock_methods = Fcons (intern ("flock"), Vmail_lock_methods); | |
| 4449 #endif | |
| 4450 #ifdef HAVE_MMDF | |
| 4451 Vmail_lock_methods = Fcons (intern ("mmdf"), Vmail_lock_methods); | |
| 4452 #endif | |
| 4453 #ifdef HAVE_LOCKING | |
| 4454 Vmail_lock_methods = Fcons (intern ("locking"), Vmail_lock_methods); | |
| 4455 #endif | |
| 4456 } | |
| 442 | 4457 |
| 438 | 4458 DEFVAR_CONST_LISP ("configure-mail-lock-method", &Vconfigure_mail_lock_method /* |
| 4459 Mail spool locking method suggested by configure. This is one | |
| 4460 of the symbols in MAIL-LOCK-METHODS. | |
| 4461 */ ); | |
| 4462 { | |
| 1303 | 4463 #if defined (MAIL_LOCK_FLOCK) && defined (HAVE_FLOCK) |
| 771 | 4464 Vconfigure_mail_lock_method = intern ("flock"); |
| 1303 | 4465 #elif defined (MAIL_LOCK_LOCKF) && defined (HAVE_LOCKF) |
| 771 | 4466 Vconfigure_mail_lock_method = intern ("lockf"); |
| 1303 | 4467 #elif defined (MAIL_LOCK_MMDF) && defined (HAVE_MMDF) |
| 771 | 4468 Vconfigure_mail_lock_method = intern ("mmdf"); |
| 1303 | 4469 #elif defined (MAIL_LOCK_LOCKING) && defined (HAVE_LOCKING) |
| 771 | 4470 Vconfigure_mail_lock_method = intern ("locking"); |
| 438 | 4471 #else |
| 771 | 4472 Vconfigure_mail_lock_method = intern ("dot"); |
| 438 | 4473 #endif |
| 4474 } | |
| 428 | 4475 } |
| 4476 | |
| 4477 void | |
| 4478 complex_vars_of_emacs (void) | |
| 4479 { | |
| 4480 /* This is all related to path searching. */ | |
| 4481 | |
| 4482 DEFVAR_LISP ("emacs-program-name", &Vemacs_program_name /* | |
| 4483 *Name of the Emacs variant. | |
| 4484 For example, this may be \"xemacs\" or \"infodock\". | |
| 4485 This is mainly meant for use in path searching. | |
| 4486 */ ); | |
| 771 | 4487 Vemacs_program_name = build_ext_string (PATH_PROGNAME, Qfile_name); |
| 428 | 4488 |
| 4489 DEFVAR_LISP ("emacs-program-version", &Vemacs_program_version /* | |
| 4490 *Version of the Emacs variant. | |
| 444 | 4491 This typically has the form NN.NN-bNN. |
| 428 | 4492 This is mainly meant for use in path searching. |
| 4493 */ ); | |
| 771 | 4494 Vemacs_program_version = build_ext_string (PATH_VERSION, Qfile_name); |
| 428 | 4495 |
| 4496 DEFVAR_LISP ("exec-path", &Vexec_path /* | |
| 4497 *List of directories to search programs to run in subprocesses. | |
| 4498 Each element is a string (directory name) or nil (try default directory). | |
| 4499 */ ); | |
| 4500 Vexec_path = Qnil; | |
| 4501 | |
| 4502 DEFVAR_LISP ("exec-directory", &Vexec_directory /* | |
| 4503 *Directory of architecture-dependent files that come with XEmacs, | |
| 4504 especially executable programs intended for XEmacs to invoke. | |
| 4505 */ ); | |
| 4506 Vexec_directory = Qnil; | |
| 4507 | |
| 4508 DEFVAR_LISP ("configure-exec-directory", &Vconfigure_exec_directory /* | |
| 4509 For internal use by the build procedure only. | |
| 444 | 4510 configure's idea of what `exec-directory' will be. |
| 428 | 4511 */ ); |
| 4512 #ifdef PATH_EXEC | |
| 4513 Vconfigure_exec_directory = Ffile_name_as_directory | |
| 771 | 4514 (build_ext_string (PATH_EXEC, Qfile_name)); |
| 428 | 4515 #else |
| 4516 Vconfigure_exec_directory = Qnil; | |
| 4517 #endif | |
| 4518 | |
| 4519 DEFVAR_LISP ("lisp-directory", &Vlisp_directory /* | |
| 4520 *Directory of core Lisp files that come with XEmacs. | |
| 4521 */ ); | |
| 4522 Vlisp_directory = Qnil; | |
| 4523 | |
| 4524 DEFVAR_LISP ("configure-lisp-directory", &Vconfigure_lisp_directory /* | |
| 4525 For internal use by the build procedure only. | |
| 444 | 4526 configure's idea of what `lisp-directory' will be. |
| 428 | 4527 */ ); |
| 4528 #ifdef PATH_LOADSEARCH | |
| 4529 Vconfigure_lisp_directory = Ffile_name_as_directory | |
| 771 | 4530 (build_ext_string (PATH_LOADSEARCH, Qfile_name)); |
| 428 | 4531 #else |
| 4532 Vconfigure_lisp_directory = Qnil; | |
| 4533 #endif | |
| 4534 | |
| 460 | 4535 DEFVAR_LISP ("mule-lisp-directory", &Vmule_lisp_directory /* |
| 4536 *Directory of Mule Lisp files that come with XEmacs. | |
| 4537 */ ); | |
| 4538 Vmule_lisp_directory = Qnil; | |
| 4539 | |
| 4540 DEFVAR_LISP ("configure-mule-lisp-directory", &Vconfigure_mule_lisp_directory /* | |
| 4541 For internal use by the build procedure only. | |
| 4542 configure's idea of what `mule-lisp-directory' will be. | |
| 4543 */ ); | |
| 4544 #ifdef PATH_MULELOADSEARCH | |
| 4545 Vconfigure_mule_lisp_directory = Ffile_name_as_directory | |
| 2367 | 4546 (build_ext_string (PATH_MULELOADSEARCH, Qfile_name); |
| 460 | 4547 #else |
| 4548 Vconfigure_mule_lisp_directory = Qnil; | |
| 4549 #endif | |
| 4550 | |
| 428 | 4551 DEFVAR_LISP ("module-directory", &Vmodule_directory /* |
| 4552 *Directory of core dynamic modules that come with XEmacs. | |
| 4553 */ ); | |
| 4554 Vmodule_directory = Qnil; | |
| 4555 | |
| 4556 DEFVAR_LISP ("configure-module-directory", &Vconfigure_module_directory /* | |
| 4557 For internal use by the build procedure only. | |
| 444 | 4558 configure's idea of what `module-directory' will be. |
| 428 | 4559 */ ); |
| 4560 #ifdef PATH_MODULESEARCH | |
| 4561 Vconfigure_module_directory = Ffile_name_as_directory | |
| 771 | 4562 (build_ext_string (PATH_MODULESEARCH, Qfile_name)); |
| 428 | 4563 #else |
| 4564 Vconfigure_module_directory = Qnil; | |
| 4565 #endif | |
| 4566 | |
| 3179 | 4567 DEFVAR_LISP ("configure-early-package-directories", &Vconfigure_early_package_directories /* |
| 4568 For internal use by the build procedure only. | |
| 4569 configure's idea of what the early package directories will be. | |
| 4570 */ ); | |
| 4571 #ifdef PATH_EARLY_PACKAGE_DIRECTORIES | |
| 4572 Vconfigure_early_package_directories = split_external_path (PATH_EARLY_PACKAGE_DIRECTORIES); | |
| 4573 #else | |
| 4574 Vconfigure_early_package_directories = Qnil; | |
| 4575 #endif | |
| 4576 | |
| 4577 DEFVAR_LISP ("configure-late-package-directories", &Vconfigure_late_package_directories /* | |
| 4578 For internal use by the build procedure only. | |
| 4579 configure's idea of what the late package directories will be. | |
| 4580 */ ); | |
| 4581 #ifdef PATH_LATE_PACKAGE_DIRECTORIES | |
| 4582 Vconfigure_late_package_directories = split_external_path (PATH_LATE_PACKAGE_DIRECTORIES); | |
| 4583 #else | |
| 4584 Vconfigure_late_package_directories = Qnil; | |
| 4585 #endif | |
| 4586 | |
| 4587 DEFVAR_LISP ("configure-last-package-directories", &Vconfigure_last_package_directories /* | |
| 4588 For internal use by the build procedure only. | |
| 4589 configure's idea of what the last package directories will be. | |
| 4590 */ ); | |
| 4591 #ifdef PATH_LAST_PACKAGE_DIRECTORIES | |
| 4592 Vconfigure_last_package_directories = split_external_path (PATH_LAST_PACKAGE_DIRECTORIES); | |
| 4593 #else | |
| 4594 Vconfigure_last_package_directories = Qnil; | |
| 4595 #endif | |
| 4596 | |
| 428 | 4597 DEFVAR_LISP ("configure-package-path", &Vconfigure_package_path /* |
| 4598 For internal use by the build procedure only. | |
| 4599 configure's idea of what the package path will be. | |
| 4600 */ ); | |
| 4601 #ifdef PATH_PACKAGEPATH | |
| 771 | 4602 Vconfigure_package_path = split_external_path (PATH_PACKAGEPATH); |
| 428 | 4603 #else |
| 4604 Vconfigure_package_path = Qnil; | |
| 4605 #endif | |
| 4606 | |
| 4607 DEFVAR_LISP ("data-directory", &Vdata_directory /* | |
| 4608 *Directory of architecture-independent files that come with XEmacs, | |
| 4609 intended for XEmacs to use. | |
| 4610 Use of this variable in new code is almost never correct. See the | |
| 442 | 4611 functions `locate-data-file' and `locate-data-directory' and the variable |
| 4612 `data-directory-list'. | |
| 428 | 4613 */ ); |
| 4614 Vdata_directory = Qnil; | |
| 4615 | |
| 4616 DEFVAR_LISP ("configure-data-directory", &Vconfigure_data_directory /* | |
| 4617 For internal use by the build procedure only. | |
| 444 | 4618 configure's idea of what `data-directory' will be. |
| 428 | 4619 */ ); |
| 4620 #ifdef PATH_DATA | |
| 4621 Vconfigure_data_directory = Ffile_name_as_directory | |
| 771 | 4622 (build_ext_string (PATH_DATA, Qfile_name)); |
| 428 | 4623 #else |
| 4624 Vconfigure_data_directory = Qnil; | |
| 4625 #endif | |
| 4626 | |
| 4627 DEFVAR_LISP ("data-directory-list", &Vdata_directory_list /* | |
| 4628 *List of directories of architecture-independent files that come with XEmacs | |
| 4629 or were installed as packages, and are intended for XEmacs to use. | |
| 4630 */ ); | |
| 4631 Vdata_directory_list = Qnil; | |
| 4632 | |
| 4633 DEFVAR_LISP ("site-directory", &Vsite_directory /* | |
| 4634 *Directory of site-specific Lisp files that come with XEmacs. | |
| 4635 */ ); | |
| 4636 Vsite_directory = Qnil; | |
| 4637 | |
| 4638 DEFVAR_LISP ("configure-site-directory", &Vconfigure_site_directory /* | |
| 4639 For internal use by the build procedure only. | |
| 444 | 4640 configure's idea of what `site-directory' will be. |
| 428 | 4641 */ ); |
| 4642 #ifdef PATH_SITE | |
| 4643 Vconfigure_site_directory = Ffile_name_as_directory | |
| 771 | 4644 (build_ext_string (PATH_SITE, Qfile_name)); |
| 428 | 4645 #else |
| 4646 Vconfigure_site_directory = Qnil; | |
| 4647 #endif | |
| 4648 | |
| 4649 DEFVAR_LISP ("site-module-directory", &Vsite_module_directory /* | |
| 4650 *Directory of site-specific loadable modules that come with XEmacs. | |
| 4651 */ ); | |
| 4652 Vsite_module_directory = Qnil; | |
| 4653 | |
| 4654 DEFVAR_LISP ("configure-site-module-directory", &Vconfigure_site_module_directory /* | |
| 4655 For internal use by the build procedure only. | |
| 444 | 4656 configure's idea of what `site-directory' will be. |
| 428 | 4657 */ ); |
| 4658 #ifdef PATH_SITE_MODULES | |
| 4659 Vconfigure_site_module_directory = Ffile_name_as_directory | |
| 771 | 4660 (build_ext_string (PATH_SITE_MODULES, Qfile_name)); |
| 428 | 4661 #else |
| 4662 Vconfigure_site_module_directory = Qnil; | |
| 4663 #endif | |
| 4664 | |
| 4665 DEFVAR_LISP ("doc-directory", &Vdoc_directory /* | |
| 4666 *Directory containing the DOC file that comes with XEmacs. | |
| 444 | 4667 This is usually the same as `exec-directory'. |
| 428 | 4668 */ ); |
| 4669 Vdoc_directory = Qnil; | |
| 4670 | |
| 4671 DEFVAR_LISP ("configure-doc-directory", &Vconfigure_doc_directory /* | |
| 4672 For internal use by the build procedure only. | |
| 444 | 4673 configure's idea of what `doc-directory' will be. |
| 428 | 4674 */ ); |
| 4675 #ifdef PATH_DOC | |
| 4676 Vconfigure_doc_directory = Ffile_name_as_directory | |
| 771 | 4677 (build_ext_string (PATH_DOC, Qfile_name)); |
| 428 | 4678 #else |
| 4679 Vconfigure_doc_directory = Qnil; | |
| 4680 #endif | |
| 4681 | |
| 4682 DEFVAR_LISP ("configure-exec-prefix-directory", &Vconfigure_exec_prefix_directory /* | |
| 4683 For internal use by the build procedure only. | |
| 444 | 4684 configure's idea of what `exec-prefix-directory' will be. |
| 428 | 4685 */ ); |
| 4686 #ifdef PATH_EXEC_PREFIX | |
| 4687 Vconfigure_exec_prefix_directory = Ffile_name_as_directory | |
| 771 | 4688 (build_ext_string (PATH_EXEC_PREFIX, Qfile_name)); |
| 428 | 4689 #else |
| 4690 Vconfigure_exec_prefix_directory = Qnil; | |
| 4691 #endif | |
| 4692 | |
| 4693 DEFVAR_LISP ("configure-prefix-directory", &Vconfigure_prefix_directory /* | |
| 4694 For internal use by the build procedure only. | |
| 444 | 4695 configure's idea of what `prefix-directory' will be. |
| 428 | 4696 */ ); |
| 4697 #ifdef PATH_PREFIX | |
| 4698 Vconfigure_prefix_directory = Ffile_name_as_directory | |
| 771 | 4699 (build_ext_string (PATH_PREFIX, Qfile_name)); |
| 428 | 4700 #else |
| 4701 Vconfigure_prefix_directory = Qnil; | |
| 4702 #endif | |
| 4703 | |
| 4704 DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory /* | |
| 4705 For internal use by the build procedure only. | |
| 4706 This is the name of the directory in which the build procedure installed | |
| 4707 Emacs's info files; the default value for Info-default-directory-list | |
| 4708 includes this. | |
| 4709 */ ); | |
| 4710 #ifdef PATH_INFO | |
| 4711 Vconfigure_info_directory = | |
| 771 | 4712 Ffile_name_as_directory (build_ext_string (PATH_INFO, Qfile_name)); |
| 428 | 4713 #else |
| 4714 Vconfigure_info_directory = Qnil; | |
| 4715 #endif | |
| 4716 | |
| 4717 DEFVAR_LISP ("configure-info-path", &Vconfigure_info_path /* | |
| 4718 The configured initial path for info documentation. | |
| 4719 */ ); | |
| 4720 #ifdef PATH_INFOPATH | |
| 771 | 4721 Vconfigure_info_path = split_external_path (PATH_INFOPATH); |
| 428 | 4722 #else |
| 4723 Vconfigure_info_path = Qnil; | |
| 4724 #endif | |
| 4725 } | |
| 4726 | |
| 1303 | 4727 #if defined (__sgi) && !defined (PDUMP) |
| 428 | 4728 /* This is so tremendously ugly I'd puke. But then, it works. |
| 4729 * The target is to override the static constructor from the | |
| 442 | 4730 * libiflPNG.so library which is masquerading as libz, and |
| 428 | 4731 * cores on us when re-started from the dumped executable. |
| 4732 * This will have to go for 21.1 -- OG. | |
| 4733 */ | |
| 446 | 4734 void __sti__iflPNGFile_c___ (void); |
| 4735 void | |
| 4736 __sti__iflPNGFile_c___ (void) | |
| 428 | 4737 { |
| 4738 } | |
| 4739 | |
| 4740 #endif | |
| 771 | 4741 |
| 2210 | 4742 DOESNT_RETURN |
| 771 | 4743 really_abort (void) |
| 4744 { | |
| 4745 abort (); | |
| 4746 } |