PageRenderTime 73ms CodeModel.GetById 31ms RepoModel.GetById 0ms app.codeStats 1ms

/src/emacs.c

https://bitbucket.org/jsparkes/xemacs-gtk
C | 4802 lines | 2771 code | 517 blank | 1514 comment | 292 complexity | 7b4f9ec6ca1b41c6835967e1d35d1582 MD5 | raw file
Possible License(s): GPL-3.0, BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

    

  1. /* XEmacs -- Fully extensible Emacs, running on Unix and other platforms.
    2. 

  2.    Copyright (C) 1985, 1986, 1987, 1992, 1993, 1994
    3. 

  3.    Free Software Foundation, Inc.
    4. 

  4.    Copyright (C) 1995 Sun Microsystems, Inc.
    5. 

  5.    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2010 Ben Wing.
    6. 

    7. 

  7. This file is part of XEmacs.
    8. 

    9. 

  9. XEmacs is free software: you can redistribute it and/or modify it
    10. 

  10. under the terms of the GNU General Public License as published by the
    11. 

  11. Free Software Foundation, either version 3 of the License, or (at your
    12. 

  12. option) any later version.
    13. 

    14. 

  14. XEmacs is distributed in the hope that it will be useful, but WITHOUT
    15. 

  15. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    16. 

  16. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    17. 

  17. for more details.
    18. 

    19. 

  19. You should have received a copy of the GNU General Public License
    20. 

  20. along with XEmacs.  If not, see <http://www.gnu.org/licenses/>. */
    21. 

  21. 

  22. /* Synched up with: Mule 2.0, FSF 19.28. */
    23. 

  23. 

  24. /* This file has been Mule-ized, Ben Wing, 10-7-04. */
    25. 

  25. 

  26. /* Capsule summary of the various releases of Lucid Emacs/XEmacs and
    27. 

  27.    FSF/GNU Emacs. (Copied from the Internals Manual, where the
    28. 

  28.    canonical version lives.) Provided here for use in cross-referencing
    29. 

  29.    version releases and dates in comments, esp. in the authorship
    30. 

  30.    comments at the beginning of each file.  More information about
    31. 

  31.    history can be found in the beginning of the Internals Manual and
    32. 

  32.    in the About page.
    33. 

    34. 

    35. 

  35. -- A time line for Lucid Emacs/XEmacs is
    36. 

    37. 

  37. Version 19.0 shipped with Energize 1.0, April 1992.
    38. 

  38. Version 19.1 released June 4, 1992.
    39. 

  39. Version 19.2 released June 19, 1992.
    40. 

  40. Version 19.3 released September 9, 1992.
    41. 

  41. Version 19.4 released January 21, 1993.
    42. 

  42. Version 19.5 released February 5, 1993.  This was a repackaging of 19.4 with a
    43. 

  43.   few bug fixes and shipped with Energize 2.0.  It was a trade-show giveaway
    44. 

  44.   and never released to the net.
    45. 

  45. Version 19.6 released April 9, 1993.
    46. 

  46. Version 19.7 was a repackaging of 19.6 with a few bug fixes and
    47. 

  47.   shipped with Energize 2.1.  Never released to the net.
    48. 

  48. Version 19.8 released September 6, 1993. (Epoch merger, preliminary I18N
    49. 

  49.   support)
    50. 

  50. Version 19.9 released January 12, 1994. (Scrollbars, Athena.)
    51. 

  51. Version 19.10 released May 27, 1994.  Known as "Lucid Emacs" when
    52. 

  52.   shipped by Lucid, and as "XEmacs" when shipped by Sun; but Lucid
    53. 

  53.   went out of business a few days later and it's unclear very many
    54. 

  54.   copies of 19.10 were released by Lucid. (Last release by Jamie Zawinski.)
    55. 

  55. Version 19.11 (first XEmacs) released September 13, 1994.
    56. 

  56. Version 19.12 released June 23, 1995.
    57. 

  57. Version 19.13 released September 1, 1995.
    58. 

  58. Version 19.14 released June 23, 1996.
    59. 

  59. Version 20.0 released February 9, 1997.
    60. 

  60. Version 19.15 released March 28, 1997.
    61. 

  61. Version 20.1 (not released to the net) April 15, 1997.
    62. 

  62. Version 20.2 released May 16, 1997.
    63. 

  63. Version 19.16 released October 31, 1997; retiring of v19 series.
    64. 

  64. Version 20.3 (the first stable version of XEmacs 20.x) released November 30,
    65. 

  65.   1997.
    66. 

  66. Version 20.4 released February 28, 1998. (Jamie claims this version is the
    67. 

  67.   "first reasonably stable release with MULE support" and says that "XEmacs
    68. 

  68.   'core' and 'packages' now packaged separately.")
    69. 

  69. Version 21.0-pre5 released July 18, 1998. (Jamie says "Numbering scheme goes
    70. 

  70.   wonky due to switch to stable + unstable branches.")
    71. 

  71. Version 21.0.60 released December 10, 1998. (The version naming scheme was
    72. 

  72.   changed at this point: [a] the second version number is odd for stable
    73. 

  73.   versions, even for beta versions; [b] a third version number is added,
    74. 

  74.   replacing the "beta xxx" ending for beta versions and allowing for
    75. 

  75.   periodic maintenance releases for stable versions.  Therefore, 21.0 was
    76. 

  76.   never "officially" released; similarly for 21.2, etc.)
    77. 

  77. Version 21.0.61 released January 4, 1999.
    78. 

  78. Version 21.0.63 released February 3, 1999.
    79. 

  79. Version 21.0.64 released March 1, 1999.
    80. 

  80. Version 21.0.65 released March 5, 1999.
    81. 

  81. Version 21.0.66 released March 12, 1999.
    82. 

  82. Version 21.0.67 released March 25, 1999.
    83. 

  83. Version 21.1.2 released May 14, 1999; on comp.emacs, May 28. (This is
    84. 

  84.  the followup to 21.0.67.  The second version number was bumped to indicate
    85. 

  85.  the beginning of the "stable" series.)
    86. 

  86. Version 21.1.3 released June 26, 1999.
    87. 

  87. Version 21.1.4 released July 8, 1999.
    88. 

  88. Version 21.1.6 released August 14, 1999. (There was no 21.1.5.)
    89. 

  89. Version 21.1.7 released September 26, 1999.
    90. 

  90. Version 21.1.8 released November 2, 1999.
    91. 

  91. Version 21.1.9 released February 13, 2000.
    92. 

  92. Version 21.1.10 released May 7, 2000.
    93. 

  93. Version 21.1.10a released June 24, 2000.
    94. 

  94. Version 21.1.11 released July 18, 2000.
    95. 

  95. Version 21.1.12 released August 5, 2000.
    96. 

  96. Version 21.1.13 released January 7, 2001.
    97. 

  97. Version 21.1.14 released January 27, 2001.
    98. 

  98. Version 21.2.9 released February 3, 1999.
    99. 

  99. Version 21.2.10 released February 5, 1999.
    100. 

  100. Version 21.2.11 released March 1, 1999.
    101. 

  101. Version 21.2.12 released March 5, 1999.
    102. 

  102. Version 21.2.13 released March 12, 1999.
    103. 

  103. Version 21.2.14 released May 14, 1999.
    104. 

  104. Version 21.2.15 released June 4, 1999.
    105. 

  105. Version 21.2.16 released June 11, 1999.
    106. 

  106. Version 21.2.17 released June 22, 1999.
    107. 

  107. Version 21.2.18 released July 14, 1999.
    108. 

  108. Version 21.2.19 released July 30, 1999.
    109. 

  109. Version 21.2.20 released November 10, 1999.
    110. 

  110. Version 21.2.21 released November 28, 1999.
    111. 

  111. Version 21.2.22 released November 29, 1999.
    112. 

  112. Version 21.2.23 released December 7, 1999.
    113. 

  113. Version 21.2.24 released December 14, 1999.
    114. 

  114. Version 21.2.25 released December 24, 1999.
    115. 

  115. Version 21.2.26 released December 31, 1999.
    116. 

  116. Version 21.2.27 released January 18, 2000.
    117. 

  117. Version 21.2.28 released February 7, 2000.
    118. 

  118. Version 21.2.29 released February 16, 2000.
    119. 

  119. Version 21.2.30 released February 21, 2000.
    120. 

  120. Version 21.2.31 released February 23, 2000.
    121. 

  121. Version 21.2.32 released March 20, 2000.
    122. 

  122. Version 21.2.33 released May 1, 2000.
    123. 

  123. Version 21.2.34 released May 28, 2000.
    124. 

  124. Version 21.2.35 released July 19, 2000.
    125. 

  125. Version 21.2.36 released October 4, 2000.
    126. 

  126. Version 21.2.37 released November 14, 2000.
    127. 

  127. Version 21.2.38 released December 5, 2000.
    128. 

  128. Version 21.2.39 released December 31, 2000.
    129. 

  129. Version 21.2.40 released January 8, 2001.
    130. 

  130. Version 21.2.41 "Polyhymnia" released January 17, 2001.
    131. 

  131. Version 21.2.42 "Poseidon" released January 20, 2001.
    132. 

  132. Version 21.2.43 "Terspichore" released January 26, 2001.
    133. 

  133. Version 21.2.44 "Thalia" released February 8, 2001.
    134. 

  134. Version 21.2.45 "Thelxepeia" released February 23, 2001.
    135. 

  135. Version 21.2.46 "Urania" released March 21, 2001.
    136. 

  136. Version 21.2.47 "Zephir" released April 14, 2001.
    137. 

  137. Version 21.4.0 "Solid Vapor" released April 16, 2001.
    138. 

  138. Version 21.4.1 "Copyleft" released April 19, 2001.
    139. 

  139. Version 21.4.2 "Developer-Friendly Unix APIs" released May 10, 2001.
    140. 

  140. Version 21.4.3 "Academic Rigor" released May 17, 2001.
    141. 

  141. Version 21.4.4 "Artificial Intelligence" released July 28, 2001.
    142. 

  142. Version 21.4.5 "Civil Service" released October 23, 2001.
    143. 

  143. Version 21.4.6 "Common Lisp" released December 17, 2001.
    144. 

  144. Version 21.4.7 "Economic Science" released May 4, 2002.
    145. 

  145. Version 21.4.8 "Honest Recruiter" released May 9, 2002.
    146. 

  146. Version 21.4.9 "Informed Management" released August 23, 2002.
    147. 

  147. Version 21.4.10 "Military Intelligence" released November 2, 2002.
    148. 

  148. Version 21.4.11 "Native Windows TTY Support" released January 3, 2003.
    149. 

  149. Version 21.4.12 "Portable Code" released January 15, 2003.
    150. 

  150. Version 21.4.13 "Rational FORTRAN" released May 25, 2003.
    151. 

  151. Version 21.4.14 "Reasonable Discussion" released September 3, 2003.
    152. 

  152. Version 21.4.15 "Security Through Obscurity" released February 2, 2004.
    153. 

  153. Version 21.5.0 "alfalfa" released April 18, 2001.
    154. 

  154. Version 21.5.1 "anise" released May 9, 2001.
    155. 

  155. Version 21.5.2 "artichoke" released July 28, 2001.
    156. 

  156. Version 21.5.3 "asparagus" released September 7, 2001.
    157. 

  157. Version 21.5.4 "bamboo" released January 8, 2002.
    158. 

  158. Version 21.5.5 "beets" released March 5, 2002.
    159. 

  159. Version 21.5.6 "bok choi" released April 5, 2002.
    160. 

  160. Version 21.5.7 "broccoflower" released July 2, 2002.
    161. 

  161. Version 21.5.8 "broccoli" released July 27, 2002.
    162. 

  162. Version 21.5.9 "brussels sprouts" released August 30, 2002.
    163. 

  163. Version 21.5.10 "burdock" released January 4, 2003.
    164. 

  164. Version 21.5.11 "cabbage" released February 16, 2003.
    165. 

  165. Version 21.5.12 "carrot" released April 24, 2003.
    166. 

  166. Version 21.5.13 "cauliflower" released May 10, 2003.
    167. 

  167. Version 21.5.14 "cassava" released June 1, 2003.
    168. 

  168. Version 21.5.15 "celery" released September 3, 2003.
    169. 

  169. Version 21.5.16 "celeriac" released September 26, 2003.
    170. 

  170. Version 21.5.17 "chayote" released March 22, 2004.
    171. 

  171. Version 21.5.18 "chestnut" released October 22, 2004.
    172. 

    173. 

    174. 

  174. -- A time line for GNU Emacs version 19 is
    175. 

    176. 

  176. version 19.7 (beta) (first beta release) released ??????; prob. late May 1993.
    177. 

  177. version 19.8 (beta) released May 27, 1993.
    178. 

  178. version 19.9 (beta) released May 27, 1993.
    179. 

  179. version 19.10 (beta) released May 30, 1993.
    180. 

  180. version 19.11 (beta) released June 1, 1993.
    181. 

  181. version 19.12 (beta) released June 2, 1993.
    182. 

  182. version 19.13 (beta) released June 8, 1993.
    183. 

  183. version 19.14 (beta) released June 17, 1993.
    184. 

  184. version 19.15 (beta) released June 19, 1993.
    185. 

  185. version 19.16 (beta) released July 6, 1993.
    186. 

  186. version 19.17 (beta) released late July, 1993.
    187. 

  187. version 19.18 (beta) released August 9, 1993.
    188. 

  188. version 19.19 (beta) released August 15, 1993.
    189. 

  189. version 19.20 (beta) released November 17, 1993.
    190. 

  190. version 19.21 (beta) released November 17, 1993.
    191. 

  191. version 19.22 (beta) released November 28, 1993.
    192. 

  192. version 19.23 (beta) released on comp.emacs, May 17, 1994.
    193. 

  193. version 19.24 (beta) released May 16, 1994.
    194. 

  194. version 19.25 (beta) released June 3, 1994.
    195. 

  195. version 19.26 (beta) released September 11, 1994.
    196. 

  196. version 19.27 (beta) released September 14, 1994.
    197. 

  197. version 19.28 (first ``official'' release) released November 1, 1994.
    198. 

  198. version 19.29 released June 21, 1995.
    199. 

  199. version 19.30 released November 24, 1995.
    200. 

  200. version 19.31 released May 25, 1996.
    201. 

  201. version 19.32 released July 31, 1996.
    202. 

  202. version 19.33 released August 11, 1996.
    203. 

  203. version 19.34 released August 21, 1996; on comp.emacs, August 22.
    204. 

  204. version 19.34b released September 6, 1996.
    205. 

    206. 

    207. 

  207. -- A time line for GNU Emacs versions 20 and 21 is
    208. 

    209. 

  209. version 20.1 released September 17, 1997.
    210. 

  210. version 20.2 released September 20, 1997.
    211. 

  211. version 20.3 released August 19, 1998.
    212. 

  212. version 20.4 released July 12, 1999; on comp.emacs, July 27.
    213. 

  213. version 21.1 released October 20, 2001.
    214. 

  214. Version 21.2 released March 16, 2002.
    215. 

  215. Version 21.3 released March 19, 2003.
    216. 

    217. 

    218. 

  218. -- A time line for GNU Emacs version 18 and older is
    219. 

    220. 

  220. GNU Emacs version 15 (15.34) was released sometime in 1984 or 1985 and
    221. 

  221.   shared some code with a version of Emacs written by James Gosling (the
    222. 

  222.   same James Gosling who later created the Java language).
    223. 

  223. GNU Emacs version 16 (first released version was 16.56) was released on
    224. 

  224.   July 15, 1985.  All Gosling code was removed due to potential copyright
    225. 

  225.   problems with the code.
    226. 

  226. version 16.57: released on September 16, 1985.
    227. 

  227. versions 16.58, 16.59: released on September 17, 1985.
    228. 

  228. version 16.60: released on September 19, 1985.  These later version 16's
    229. 

  229.   incorporated patches from the net, esp. for getting Emacs to work under
    230. 

  230.   System V.
    231. 

  231. version 17.36 (first official v17 release) released on December 20, 1985.
    232. 

  232.   Included a TeX-able user manual.  First official unpatched version that
    233. 

  233.    worked on vanilla System V machines.
    234. 

  234. version 17.43 (second official v17 release) released on January 25, 1986.
    235. 

  235. version 17.45 released on January 30, 1986.
    236. 

  236. version 17.46 released on February 4, 1986.
    237. 

  237. version 17.48 released on February 10, 1986.
    238. 

  238. version 17.49 released on February 12, 1986.
    239. 

  239. version 17.55 released on March 18, 1986.
    240. 

  240. version 17.57 released on March 27, 1986.
    241. 

  241. version 17.58 released on April 4, 1986.
    242. 

  242. version 17.61 released on April 12, 1986.
    243. 

  243. version 17.63 released on May 7, 1986.
    244. 

  244. version 17.64 released on May 12, 1986.
    245. 

  245. version 18.24 (a beta version) released on October 2, 1986.
    246. 

  246. version 18.30 (a beta version) released on November 15, 1986.
    247. 

  247. version 18.31 (a beta version) released on November 23, 1986.
    248. 

  248. version 18.32 (a beta version) released on December 7, 1986.
    249. 

  249. version 18.33 (a beta version) released on December 12, 1986.
    250. 

  250. version 18.35 (a beta version) released on January 5, 1987.
    251. 

  251. version 18.36 (a beta version) released on January 21, 1987.
    252. 

  252. January 27, 1987: The Great Usenet Renaming.  net.emacs is now comp.emacs.
    253. 

  253. version 18.37 (a beta version) released on February 12, 1987.
    254. 

  254. version 18.38 (a beta version) released on March 3, 1987.
    255. 

  255. version 18.39 (a beta version) released on March 14, 1987.
    256. 

  256. version 18.40 (a beta version) released on March 18, 1987.
    257. 

  257. version 18.41 (the first ``official'' release) released on March 22, 1987.
    258. 

  258. version 18.45 released on June 2, 1987.
    259. 

  259. version 18.46 released on June 9, 1987.
    260. 

  260. version 18.47 released on June 18, 1987.
    261. 

  261. version 18.48 released on September 3, 1987.
    262. 

  262. version 18.49 released on September 18, 1987.
    263. 

  263. version 18.50 released on February 13, 1988.
    264. 

  264. version 18.51 released on May 7, 1988.
    265. 

  265. version 18.52 released on September 1, 1988.
    266. 

  266. version 18.53 released on February 24, 1989.
    267. 

  267. version 18.54 released on April 26, 1989.
    268. 

  268. version 18.55 released on August 23, 1989.  This is the earliest version
    269. 

  269.   that is still available by FTP.
    270. 

  270. version 18.56 released on January 17, 1991.
    271. 

  271. version 18.57 released late January, 1991.
    272. 

  272. version 18.58 released ?????.
    273. 

  273. version 18.59 released October 31, 1992.
    274. 

    275. 

    276. 

  276. -- A time line for Epoch is
    277. 

    278. 

  278. Epoch 1.0 released December 14, 1989. (by Simon Kaplan, Chris Love, et al.)
    279. 

  279. Epoch 2.0 released December 23, 1989.
    280. 

  280. Epoch 3.1 released February 6, 1990.
    281. 

  281. Epoch 3.2 released December[????] 11, 1990.
    282. 

  282. Epoch 4.0 released August 27, 1990.
    283. 

    284. 

  284. */
    285. 

  285. 

  286. /* Sources for further information:
    287. 

    288. 

  288. -----------------------------------
    289. 

  289. 1. Using XEmacs, Programming Elisp:
    290. 

  290. -----------------------------------
    291. 

    292. 

  292. ;;; -- the XEmacs User's Manual (Access using the online Info browser:
    293. 

  293. ;;;       Use `Help->Info (Online Docs)->XEmacs User's Manual' (if
    294. 

  294. ;;;       there is such an entry); or get to the Info contents page
    295. 

  295. ;;;       using `Help->Info Contents' or `C-h i', and then
    296. 

  296. ;;;       *middle-click* the XEmacs link or move the cursor into the
    297. 

  297. ;;;       link and hit ENTER.  This manual contains a great deal of
    298. 

  298. ;;;       documentation on customization: Scroll down to the
    299. 

  299. ;;;       Customization link and select it in the same fashion as for
    300. 

  300. ;;;       the XEmacs link just mentioned.)
    301. 

    302. 

  302. ;;; -- the XEmacs FAQ (`C-h F' for the local version; get either the
    303. 

  303. ;;;       local version or the very latest version off the net using
    304. 

  304. ;;;       the Help menu)
    305. 

    306. 

  306. ;;; -- the XEmacs Lisp Reference Manual, containing detailed
    307. 

  307. ;;;       documentation on Elisp. (Access using Info, just like for the
    308. 

  308. ;;;       XEmacs User's Manual.)
    309. 

    310. 

  310. ;;; -- the documentation strings for specific commands, functions,
    311. 

  311. ;;;       key sequences, and variables.  NOTE: This is *not* the same
    312. 

  312. ;;;       information as in the XEmacs User's Manual or XEmacs Lisp
    313. 

  313. ;;;       Reference Manual!  In general, the doc strings are more
    314. 

  314. ;;;       terse and more up-to-date than what is found in the manuals.
    315. 

  315. ;;;       Once you understand the general concepts, these doc strings
    316. 

  316. ;;;       should be your first point of reference for further
    317. 

  317. ;;;       info. (Access using menu entries under `Help->Commands,
    318. 

  318. ;;;       Variables, Keys' or using the keyboard: `C-h k' for a key
    319. 

  319. ;;;       sequence, `C-h f' for a named command or Elisp function,
    320. 

  320. ;;;       `C-h v' for a variable.  There is various other useful
    321. 

  321. ;;;       information accessible similarly, such as `C-h a'
    322. 

  322. ;;;       ["Apropos", i.e. search for a command, function, or variable
    323. 

  323. ;;;       by name]; `C-h C-a' ["Apropos Docs", i.e. search through the
    324. 

  324. ;;;       text of the doc strings]; `C-h b' to list all key bindings;
    325. 

  325. ;;;       `C-h m' to describe the current major and minor modes; etc.
    326. 

  326. ;;;       Type `C-h ? ?' for a complete list.)
    327. 

    328. 

  328. ;;; -- Getting Started with XEmacs [aka the "New User's Guide"], a
    329. 

  329. ;;;       more introductory manual than the XEmacs User's Manual.
    330. 

  330. ;;;       (Access using Info, just like for the XEmacs User's Manual.
    331. 

  331. ;;;       There are some sections on customization here.)
    332. 

    333. 

  333. ;;; -- the XEmacs tutorial, a very simple introduction to XEmacs for
    334. 

  334. ;;;       total beginners. (`C-h t' for English; get the version in
    335. 

  335. ;;;       various languages from the Help menu)
    336. 

    337. 

  337. ;;; -- the XEmacs web site, www.xemacs.org.
    338. 

    339. 

  339. ;;; -- the XEmacs mailing lists (xemacs-FOO@xemacs.org;
    340. 

  340. ;;;       see http://www.xemacs.org/Lists/ for more info.  Before
    341. 

  341. ;;;       posting, consider looking through the archives -- they go back
    342. 

  342. ;;;       years and there is a powerful searching interface.  Currently
    343. 

  343. ;;;       the archives are at http://list-archive.xemacs.org/, but if
    344. 

  344. ;;;       this doesn't work, you can always access them through
    345. 

  345. ;;;       www.xemacs.org.)
    346. 

    347. 

  347. ;;; -- the XEmacs newsgroup, comp.emacs.xemacs.  This is
    348. 

  348. ;;;       bi-directionally gatewayed with xemacs@xemacs.org.  WARNING:
    349. 

  349. ;;;       The developers do not normally hang out on this newsgroup.  If
    350. 

  350. ;;;       you need to contact them, use xemacs-beta@xemacs.org.
    351. 

    352. 

  352. ;;; -- the XEmacs internals manual, for those interested in working on
    353. 

  353. ;;;       the XEmacs C code. (Available through Info.)
    354. 

    355. 

  355. ;;; -- `Help->About XEmacs' to find out who the maintainers are.
    356. 

    357. 

  357. ---------------------
    358. 

  358. 2. Developing XEmacs:
    359. 

  359. ---------------------
    360. 

    361. 

  361. -- the internals manual, man/internals/internals.texi
    362. 

    363. 

  363. -- long comments at the head of certain files:
    364. 

    365. 

  365.      emacs.c
    366. 

  366.      extents.c
    367. 

  367.      text.c
    368. 

  368.      text.h 
    369. 

  369.      lisp.h 
    370. 

  370.      redisplay.h
    371. 

  371.      dynarr.c
    372. 

  372.      blocktype.c
    373. 

  373.      eval.c
    374. 

  374.      event-Xt.c (sort of)
    375. 

  375.      event-stream.c (command event queue)
    376. 

  376.      frame.c
    377. 

  377.      intl-encap-win32.c
    378. 

  378.      keymap.c
    379. 

  379.      line-number.c (a little bit)
    380. 

  380.      menubar-msw.c (sort of)
    381. 

  381.      menubar-x.c (sort of)
    382. 

  382.      mule-canna.c (sort of)
    383. 

  383.      mule-ccl.c
    384. 

  384.      mule-coding.c (scattered in the file)
    385. 

  385.      mule-wnn.c (in japanese)
    386. 

  386.      ntheap.c (near the top)
    387. 

  387.      redisplay.c (various scattered)
    388. 

  388.      regex.c (various scattered)
    389. 

  389.      sysdep.c (maybe; wait_for_termination)
    390. 

  390.      unexec.c
    391. 

  391.      unicode.c
    392. 

  392.      gccache-x.c (a bit)
    393. 

    394. 

  394.      #### review .h files; write a perl program to look for long comments
    395. 

  395.      throughout the files, ignoring stuff inside of DEFUN's.
    396. 

    397. 

  397.      #### elsewhere?
    398. 

    399. 

  399. -- comments scattered throughout the sources (#### should be grouped
    400. 

  400.    together if feasible).  For example, lrecord.h (pdump and object-
    401. 

  401.    creation), alloc.c (fixed-type allocation), etc. #### fill in.
    402. 

    403. 

  403. -- Ben's Architecting XEmacs web site.
    404. 

  404.    (http://www.xemacs.org/Architecting-XEmacs/index.html; #### should be
    405. 

  405.    integrated into the sources)
    406. 

    407. 

  407. -- Back discussions on xemacs-beta (#### The juiciest tidbits, esp.
    408. 

  408.    those with specific proposals, should be extracted and stuck in
    409. 

  409.    the source)
    410. 

    411. 

  411. -- README.* in the src/ directory (and maybe other directories)
    412. 

    413. 

  413. -- The ChangeLog files, sometimes.
    414. 

    415. 

  415. */
    416. 

  416. 

  417. 

  418. 

  419. /* Note: It is necessary to specify <config.h> and not "config.h" in
    420. 

  420.    order for the --srcdir type of compilation to work properly.
    421. 

  421.    Otherwise the config.h from the srcdir, rather than the one from
    422. 

  422.    the build dir, will be used. */
    423. 

  423. 

  424. #include <config.h>
    425. 

  425. #include "lisp.h"
    426. 

  426. 

  427. #include "backtrace.h" /* run-emacs-from-temacs needs this */
    428. 

  428. #include "buffer.h"
    429. 

  429. #include "commands.h"
    430. 

  430. #include "console.h"
    431. 

  431. #include "process.h"
    432. 

  432. #include "redisplay.h"
    433. 

  433. #include "frame.h"
    434. 

  434. #include "sysdep.h"
    435. 

  435. 

  436. #include "systty.h"
    437. 

  437. #include "sysfile.h"
    438. 

  438. #include "systime.h"
    439. 

  439. #include "sysproc.h" /* for qxe_getpid() */
    440. 

  440. 

  441. #ifdef QUANTIFY
    442. 

  442. #include <quantify.h>
    443. 

  443. #endif
    444. 

  444. 

  445. #ifdef HAVE_SHLIB
    446. 

  446. #include "sysdll.h"
    447. 

  447. #endif
    448. 

  448. 

  449. #ifdef TOOLTALK
    450. 

  450. #include TT_C_H_FILE
    451. 

  451. #endif
    452. 

  452. 

  453. #ifdef WIN32_ANY
    454. 

  454. #include "console-msw.h"
    455. 

  455. #endif
    456. 

  456. 

  457. #ifdef DUMP_IN_EXEC
    458. 

  458. #ifndef WIN32_NATIVE
    459. 

  459. #include "dump-data.h"
    460. 

  460. #endif
    461. 

  461. #endif
    462. 

  462. 

  463. /* For PATH_EXEC */
    464. 

  464. #include <paths.h>
    465. 

  465. 

  466. #if defined (HEAP_IN_DATA) && !defined (PDUMP)
    467. 

  467. void report_sheap_usage (int die_if_pure_storage_exceeded);
    468. 

  468. #endif
    469. 

  469. 

  470. #if !defined (SYSTEM_MALLOC) && !defined (DOUG_LEA_MALLOC)
    471. 

  471. extern void *(*__malloc_hook)(size_t);
    472. 

  472. extern void *(*__realloc_hook)(void *, size_t);
    473. 

  473. extern void (*__free_hook)(void *);
    474. 

  474. #endif  /* not SYSTEM_MALLOC && not DOUG_LEA_MALLOC */
    475. 

  475. 

  476. /* Command line args from shell, as list of strings */
    477. 

  477. Lisp_Object Vcommand_line_args;
    478. 

  478. 

  479. /* Set nonzero after XEmacs has started up the first time.
    480. 

  480.   Prevents reinitialization of the Lisp world and keymaps
    481. 

  481.   on subsequent starts.  */
    482. 

  482. int initialized;
    483. 

  483. 

  484. #ifdef DOUG_LEA_MALLOC
    485. 

  485. # include <malloc.h>
    486. 

  486. /* Preserves a pointer to the memory allocated that copies that
    487. 

  487.    static data inside glibc's malloc.  */
    488. 

  488. static void *malloc_state_ptr;
    489. 

  489. #endif /* DOUG_LEA_MALLOC */
    490. 

  490. 

  491. # ifdef REL_ALLOC
    492. 

  492. void r_alloc_reinit (void);
    493. 

  493. # endif
    494. 

  494. 

  495. /* Variable whose value is symbol giving operating system type. */
    496. 

  496. Lisp_Object Vsystem_type;
    497. 

  497. 

  498. /* Variable whose value is string giving configuration built for.  */
    499. 

  499. Lisp_Object Vsystem_configuration;
    500. 

  500. 

  501. /* Variable whose value is string containing the configuration options
    502. 

  502.    XEmacs was built with.  */
    503. 

  503. Lisp_Object Vsystem_configuration_options;
    504. 

  504. 

  505. /* Version numbers and strings */
    506. 

  506. Lisp_Object Vemacs_major_version;
    507. 

  507. Lisp_Object Vemacs_minor_version;
    508. 

  508. Lisp_Object Vemacs_patch_level;
    509. 

  509. Lisp_Object Vemacs_beta_version;
    510. 

  510. Lisp_Object Vxemacs_codename;
    511. 

  511. Lisp_Object Vxemacs_extra_name;
    512. 

  512. Lisp_Object Vxemacs_release_date;
    513. 

  513. 

  514. /* The path under which XEmacs was invoked. */
    515. 

  515. Lisp_Object Vinvocation_path;
    516. 

  516. 

  517. /* The name under which XEmacs was invoked, with any leading directory
    518. 

  518.    names discarded.  */
    519. 

  519. Lisp_Object Vinvocation_name;
    520. 

  520. 

  521. /* The directory name from which XEmacs was invoked.  */
    522. 

  522. Lisp_Object Vinvocation_directory;
    523. 

  523. 

  524. #if 0 /* FSFmacs */
    525. 

  525. /* The directory name in which to find subdirs such as lisp and etc.
    526. 

  526.    nil means get them only from PATH_LOADSEARCH.  */
    527. 

  527. Lisp_Object Vinstallation_directory;
    528. 

  528. #endif
    529. 

  529. 

  530. Lisp_Object Vemacs_program_name, Vemacs_program_version;
    531. 

  531. Lisp_Object Vexec_path;
    532. 

  532. Lisp_Object Vexec_directory, Vconfigure_exec_directory;
    533. 

  533. Lisp_Object Vlisp_directory, Vconfigure_lisp_directory;
    534. 

  534. Lisp_Object Vmule_lisp_directory, Vconfigure_mule_lisp_directory;
    535. 

  535. Lisp_Object Vmodule_directory, Vconfigure_module_directory;
    536. 

  536. Lisp_Object Vsite_module_directory, Vconfigure_site_module_directory;
    537. 

  537. Lisp_Object Vconfigure_package_path;
    538. 

  538. Lisp_Object Vconfigure_early_package_directories;
    539. 

  539. Lisp_Object Vconfigure_late_package_directories;
    540. 

  540. Lisp_Object Vconfigure_last_package_directories;
    541. 

  541. Lisp_Object Vdata_directory, Vconfigure_data_directory;
    542. 

  542. Lisp_Object Vdoc_directory, Vconfigure_doc_directory;
    543. 

  543. Lisp_Object Vconfigure_lock_directory;
    544. 

  544. Lisp_Object Vdata_directory_list;
    545. 

  545. Lisp_Object Vconfigure_info_directory;
    546. 

  546. Lisp_Object Vsite_directory, Vconfigure_site_directory;
    547. 

  547. Lisp_Object Vconfigure_info_path;
    548. 

  548. Lisp_Object Vinternal_error_checking;
    549. 

  549. Lisp_Object Vmail_lock_methods, Vconfigure_mail_lock_method;
    550. 

  550. 

  551. /* The default base directory XEmacs is installed under. */
    552. 

  552. Lisp_Object Vconfigure_exec_prefix_directory, Vconfigure_prefix_directory;
    553. 

  553. 

  554. /* If nonzero, set XEmacs to run at this priority.  This is also used
    555. 

  555.    in child_setup and sys_suspend to make sure subshells run at normal
    556. 

  556.    priority. */
    557. 

  557. Fixnum emacs_priority;
    558. 

  558. 

  559. /* Some FSF junk with running_asynch_code, to preserve the match
    560. 

  560.    data.  Not necessary because we don't call process filters
    561. 

  561.    asynchronously (i.e. from within QUIT). */
    562. 

  562. 

  563. /* If non-zero, a window-system was specified on the command line. */
    564. 

  564. int display_arg;
    565. 

  565. 

  566. /* Type of display specified.  We cannot use a Lisp symbol here because
    567. 

  567.    Lisp symbols may not initialized at the time that we set this
    568. 

  568.    variable. */
    569. 

  569. const Ascbyte *display_use;
    570. 

  570. 

  571. /* If non-zero, then the early error handler will only print the error
    572. 

  572.    message and exit. */
    573. 

  573. int suppress_early_error_handler_backtrace;
    574. 

  574. 

  575. /* An address near the bottom of the stack.
    576. 

  576.    Tells GC how to save a copy of the stack.  */
    577. 

  577. Rawbyte *stack_bottom;
    578. 

  578. 

  579. #ifdef USG_SHARED_LIBRARIES
    580. 

  580. /* If nonzero, this is the place to put the end of the writable segment
    581. 

  581.    at startup.  */
    582. 

  582. 

  583. uintptr_t bss_end = 0;
    584. 

  584. #endif
    585. 

  585. 

  586. /* Number of bytes of writable memory we can expect to be able to get:
    587. 

  587.    Leave this as an unsigned int because it could potentially be 4G */
    588. 

  588. unsigned long lim_data;
    589. 

  589. 

  590. /* WARNING!
    591. 

    592. 

  592.    Some LISP-visible command-line options are set by XEmacs _before_ the
    593. 

  593.    data is dumped in building a --pdump XEmacs, but used _after_ it is
    594. 

  594.    restored in normal operation.  Thus the dump-time values overwrite the
    595. 

  595.    values XEmacs is getting at runtime.  Such variables must be saved
    596. 

  596.    before loading the dumpfile, and restored afterward.
    597. 

    598. 

  598.    Therefore these variables may not be initialized in vars_of_emacs().
    599. 

    600. 

  600.    The save/restore is done immediately before and after pdump_load() in
    601. 

  601.    main_1().  See that function for the current list of protected variables.
    602. 

    603. 

  603.    Note that saving/restoring is only necessary for a few variables that are
    604. 

  604.      o command line arguments effective at runtime (as opposed to dump-time),
    605. 

  605.      o parsed before pdump_load, and
    606. 

  606.      o exported to Lisp via a DEFVAR.
    607. 

  607. */
    608. 

  608. 

  609. /* Nonzero means running XEmacs without interactive terminal.  */
    610. 

  610. 

  611. int noninteractive;
    612. 

  612. 

  613. /* Value of Lisp variable `noninteractive'.
    614. 

  614.    Normally same as C variable `noninteractive'
    615. 

  615.    but nothing terrible happens if user sets this one.
    616. 

    617. 

  617.    Shadowed from the pdumper by `noninteractive'. */
    618. 

  618. 

  619. int noninteractive1;
    620. 

  620. 

  621. /* Nonzero means don't perform site-lisp searches at startup */
    622. 

  622. int inhibit_site_lisp;
    623. 

  623. 

  624. /* Nonzero means don't perform site-modules searches at startup */
    625. 

  625. int inhibit_site_modules;
    626. 

  626. 

  627. /* Nonzero means don't load user-init or site-start file */
    628. 

  628. int vanilla_inhibiting;
    629. 

  629. 

  630. /* Nonzero means don't respect early packages at startup */
    631. 

  631. int inhibit_early_packages;
    632. 

  632. 

  633. /* Nonzero means don't respect any packages at startup -- act as if they
    634. 

  634.    don't exist. */
    635. 

  635. int inhibit_all_packages;
    636. 

  636. 

  637. /* Nonzero means don't load package autoloads at startup */
    638. 

  638. int inhibit_autoloads;
    639. 

  639. 

  640. /* Nonzero means don't load the dump file (ignored if not PDUMP)  */
    641. 

  641. 

  642. int nodumpfile;
    643. 

  643. 

  644. /* Nonzero means print debug information about path searching */
    645. 

  645. int debug_paths;
    646. 

  646. 

  647. /* Save argv and argc.  */
    648. 

  648. static Wexttext **initial_argv;	/* #### currently unused */
    649. 

  649. static int initial_argc;	/* #### currently unused */
    650. 

  650. 

  651. static void sort_args (int argc, Wexttext **argv);
    652. 

  652. 

  653. Lisp_Object Qkill_emacs_hook;
    654. 

  654. Lisp_Object Qsave_buffers_kill_emacs;
    655. 

  655. 

  656. Lisp_Object Qtemacs, Qdumping, Qrestarted, Qpdump, Qbatch;
    657. 

  657. 

  658. /* Nonzero if handling a fatal error already. */
    659. 

  659. int fatal_error_in_progress;
    660. 

  660. 

  661. /* Nonzero means we're going down, so we better not run any hooks
    662. 

  662.    or do other non-essential stuff. */
    663. 

  663. int preparing_for_armageddon;
    664. 

  664. 

  665. /* Nonzero means we're in an unstable situation and need to skip
    666. 

  666.    internal->external conversions, QUIT checking and such.  This gets set
    667. 

  667.    during early startup, during shutdown, and when debug printing
    668. 

  668.    (i.e. called from a debugger such as gdb to print Lisp objects or
    669. 

  669.    backtraces).  During printing we check for this, and during conversion
    670. 

  670.    we abort if we see this. */
    671. 

  671. int inhibit_non_essential_conversion_operations;
    672. 

  672. 

  673. static JMP_BUF run_temacs_catch;
    674. 

  674. 

  675. static int run_temacs_argc;
    676. 

  676. static Wexttext **run_temacs_argv;
    677. 

  677. 

  678. #ifdef _MSC_VER
    679. 

  679. static DWORD mswindows_handle_hardware_exceptions (DWORD code);
    680. 

  680. #endif
    681. 

  681. 

  682. #ifdef WIN32_NATIVE
    683. 

  683. static DWORD CALLBACK wait_for_termination_signal (LPVOID handle);
    684. 

  684. #endif
    685. 

  685. 

  686. 
    687. 

  687. /************************************************************************/
    688. 

  688. /*                   Functions to handle arguments                      */
    689. 

  689. /************************************************************************/
    690. 

  690. 

  691. /* Code for dealing with Lisp access to the Unix command line */
    692. 

  692. 

  693. static Lisp_Object
    694. 

  694. make_arg_list_1 (int argc, Wexttext **argv, int skip_args)
    695. 

  695. {
    696. 

  696.   Lisp_Object result = Qnil;
    697. 

  697.   REGISTER int i;
    698. 

  698. 

  699.   for (i = argc - 1; i >= 0; i--)
    700. 

  700.     {
    701. 

  701.       if (i == 0 || i > skip_args)
    702. 

  702. 	{
    703. 

  703. #ifdef WIN32_NATIVE
    704. 

  704. 	  if (i == 0)
    705. 

  705. 	    {
    706. 

  706. 	      /* Do not trust to what crt0 has stuffed into argv[0] */
    707. 

  707. 	      Extbyte *full_exe_path;
    708. 

  708. 	      Lisp_Object fullpath;
    709. 

  709. 

  710. 	      full_exe_path = mswindows_get_module_file_name ();
    711. 

  711. 	      assert (full_exe_path);
    712. 

  712. 	      fullpath = build_tstr_string (full_exe_path);
    713. 

  713. 	      xfree (full_exe_path);
    714. 

  714. 	      result = Fcons (fullpath, result);
    715. 

  715. 	    }
    716. 

  716. 	  else
    717. 

  717. #endif
    718. 

  718. 	    result = Fcons (build_wext_string (argv[i],
    719. 

  719. 					       Qcommand_argument_encoding),
    720. 

  720. 			    result);
    721. 

  721. 	}
    722. 

  722.     }
    723. 

  723.   return result;
    724. 

  724. }
    725. 

  725. 

  726. Lisp_Object
    727. 

  727. make_arg_list (int argc, Wexttext **argv)
    728. 

  728. {
    729. 

  729.   return make_arg_list_1 (argc, argv, 0);
    730. 

  730. }
    731. 

  731. 

  732. /* Calling functions are also responsible for calling free_argc_argv
    733. 

  733.    when they are done with the generated list. */
    734. 

  734. void
    735. 

  735. make_argc_argv (Lisp_Object argv_list, int *argc, Wexttext ***argv)
    736. 

  736. {
    737. 

  737.   Lisp_Object next;
    738. 

  738.   int n = XFIXNUM (Flength (argv_list));
    739. 

  739.   REGISTER int i;
    740. 

  740.   *argv = xnew_array (Wexttext *, n + 1);
    741. 

  741. 

  742.   for (i = 0, next = argv_list; i < n; i++, next = XCDR (next))
    743. 

  743.     {
    744. 

  744.       CHECK_STRING (XCAR (next));
    745. 

  745. 

  746.       (*argv)[i] =
    747. 

  747. 	(Wexttext *) LISP_STRING_TO_EXTERNAL_MALLOC
    748. 

  748. 	(XCAR (next), Qcommand_argument_encoding);
    749. 

  749.     }
    750. 

  750.   (*argv) [n] = 0;
    751. 

  751.   *argc = i;
    752. 

  752. }
    753. 

  753. 

  754. void
    755. 

  755. free_argc_argv (Wexttext **argv)
    756. 

  756. {
    757. 

  757.   int elt = 0;
    758. 

  758. 

  759.   while (argv[elt])
    760. 

  760.     {
    761. 

  761.       xfree (argv[elt]);
    762. 

  762.       argv[elt] = 0;
    763. 

  763.       elt++;
    764. 

  764.     }
    765. 

  765.   xfree (argv);
    766. 

  766. }
    767. 

  767. 

  768. static void
    769. 

  769. init_cmdargs (int argc, Wexttext **argv, int skip_args)
    770. 

  770. {
    771. 

  771.   initial_argv = argv;
    772. 

  772.   initial_argc = argc;
    773. 

  773. 

  774.   Vcommand_line_args = make_arg_list_1 (argc, argv, skip_args);
    775. 

  775. }
    776. 

  776. 

  777. DEFUN ("invocation-name", Finvocation_name, 0, 0, 0, /*
    778. 

  778. Return the program name that was used to run XEmacs.
    779. 

  779. Any directory names are omitted.
    780. 

  780. */
    781. 

  781.        ())
    782. 

  782. {
    783. 

  783.   return Fcopy_sequence (Vinvocation_name);
    784. 

  784. }
    785. 

  785. 

  786. DEFUN ("invocation-directory", Finvocation_directory, 0, 0, 0, /*
    787. 

  787. Return the directory name in which the Emacs executable was located.
    788. 

  788. */
    789. 

  789.        ())
    790. 

  790. {
    791. 

  791.   return Fcopy_sequence (Vinvocation_directory);
    792. 

  792. }
    793. 

  793. 

  794. 
    795. 

  795. 

  796. /* Test whether the next argument in ARGV matches SSTR or a prefix of LSTR
    797. 

  797.    (at least MINLEN characters; if MINLEN is 0, set to size of LSTR).  If
    798. 

  798.    so, then if VALPTR is non-null (the argument is supposed to have a
    799. 

  799.    value) store in *VALPTR either the next argument or the portion of this
    800. 

  800.    one after the equal sign.  ARGV is read starting at position *SKIPPTR;
    801. 

  801.    this index is advanced by the number of arguments used.
    802. 

    803. 

  803.    Too bad we can't just use getopt for all of this, but we don't have
    804. 

  804.    enough information to do it right.  */
    805. 

  805. 

  806. static int
    807. 

  807. argmatch (Wexttext **argv, int argc, const Ascbyte *sstr, const Ascbyte *lstr,
    808. 

  808. 	  int minlen, Wexttext **valptr, int *skipptr)
    809. 

  809. {
    810. 

  810.   Wexttext *p = NULL;
    811. 

  811.   Charcount arglen;
    812. 

  812.   Wexttext *arg;
    813. 

  813. 

  814.   /* Don't access argv[argc]; give up in advance.  */
    815. 

  815.   if (argc <= *skipptr + 1)
    816. 

  816.     return 0;
    817. 

  817. 

  818.   arg = argv[*skipptr+1];
    819. 

  819.   if (arg == NULL)
    820. 

  820.     return 0;
    821. 

  821.   if (wext_strcmp_ascii (arg, sstr) == 0)
    822. 

  822.     {
    823. 

  823.       if (valptr != NULL)
    824. 

  824. 	{
    825. 

  825. 	  *valptr = argv[*skipptr+2];
    826. 

  826. 	  *skipptr += 2;
    827. 

  827. 	}
    828. 

  828.       else
    829. 

  829. 	*skipptr += 1;
    830. 

  830.       return 1;
    831. 

  831.     }
    832. 

  832.   arglen = (valptr != NULL && (p = wext_strchr (arg, '=')) != NULL
    833. 

  833. 	    ? p - arg : (Charcount) wext_strlen (arg));
    834. 

  834.   if (lstr && !minlen)
    835. 

  835.     minlen = strlen (lstr);
    836. 

  836.   if (lstr == 0 || arglen < minlen ||
    837. 

  837.       wext_strncmp_ascii (arg, lstr, arglen) != 0)
    838. 

  838.     return 0;
    839. 

  839.   else if (valptr == NULL)
    840. 

  840.     {
    841. 

  841.       *skipptr += 1;
    842. 

  842.       return 1;
    843. 

  843.     }
    844. 

  844.   else if (p != NULL)
    845. 

  845.     {
    846. 

  846.       *valptr = p + 1;
    847. 

  847.       *skipptr += 1;
    848. 

  848.       return 1;
    849. 

  849.     }
    850. 

  850.   else if (argv[*skipptr + 2] != NULL)
    851. 

  851.     {
    852. 

  852.       *valptr = argv[*skipptr + 2];
    853. 

  853.       *skipptr += 2;
    854. 

  854.       return 1;
    855. 

  855.     }
    856. 

  856.   else
    857. 

  857.     {
    858. 

  858.       return 0;
    859. 

  859.     }
    860. 

  860. }
    861. 

  861. 

  862. static void
    863. 

  863. check_compatible_window_system (const Ascbyte *must)
    864. 

  864. {
    865. 

  865.   if (display_use && strcmp (display_use, must))
    866. 

  866.     fatal ("Incompatible window system type `%s': `%s' already specified",
    867. 

  867. 	   must, display_use);
    868. 

  868.   display_use = must;
    869. 

  869. }
    870. 

  870. 

  871. 
    872. 

  872. /************************************************************************/
    873. 

  873. /*                   main and friends: XEmacs startup                   */
    874. 

  874. /************************************************************************/
    875. 

  875. 

  876. /* Make stack traces always identify version + configuration */
    877. 

  877. #define main_1 STACK_TRACE_EYE_CATCHER
    878. 

  878. 

  879. /* This function is not static, so that the compiler is less likely to
    880. 

  880.    inline it, which would make it not show up in stack traces.
    881. 

    882. 

  882.    The restart argument is a flag that indicates that main_1 is now
    883. 

  883.    being called for the second time in this invocation of xemacs; this
    884. 

  884.    happens as a result of using `run-temacs' in the command line, when
    885. 

  885.    invoking a bare (without dumped data) XEmacs (i.e. `temacs' with
    886. 

  886.    the conventional dumper or `xemacs -nd' with the pdumper).  See
    887. 

  887.    Frun_emacs_from_temacs().
    888. 

  888. */
    889. 

  889. DECLARE_DOESNT_RETURN (main_1 (int, Wexttext **, Wexttext **, int));
    890. 

  890. DOESNT_RETURN
    891. 

  891. main_1 (int argc, Wexttext **argv, Wexttext **UNUSED (envp), int restart)
    892. 

  892. {
    893. 

  893.   Rawbyte stack_bottom_variable;
    894. 

  894.   int skip_args = 0;
    895. 

  895.   Lisp_Object load_me;
    896. 

  896. 

  897. #if (!defined (SYSTEM_MALLOC) && !defined (HAVE_LIBMCHECK)	\
    898. 

  898.      && !defined (DOUG_LEA_MALLOC))
    899. 

  899.   /* Make sure that any libraries we link against haven't installed a
    900. 

  900.      hook for a gmalloc of a potentially incompatible version. */
    901. 

  901.   /* If we're using libmcheck, the hooks have already been initialized, */
    902. 

  902.   /* don't touch them. -slb */
    903. 

  903.   __malloc_hook = NULL;
    904. 

  904.   __realloc_hook = NULL;
    905. 

  905.   __free_hook = NULL;
    906. 

  906. #endif /* not SYSTEM_MALLOC or HAVE_LIBMCHECK or DOUG_LEA_MALLOC */
    907. 

  907. 

  908.   noninteractive = 0;
    909. 

  909.   display_use = NULL;
    910. 

  910.   inhibit_non_essential_conversion_operations = 1;
    911. 

  911. 

  912. #ifdef NEW_GC
    913. 

  913. #ifndef PDUMP
    914. 

  914.   if (!initialized)
    915. 

  915. #endif
    916. 

  916.     {
    917. 

  917.       if (!restart)
    918. 

  918. 	{
    919. 

  919. 	  init_mc_allocator ();
    920. 

  920. #ifdef ALLOC_TYPE_STATS
    921. 

  921. 	  init_lrecord_stats ();
    922. 

  922. #endif /* ALLOC_TYPE_STATS */
    923. 

  923. 	}
    924. 

  924.     }
    925. 

  925. #endif /* NEW_GC */
    926. 

  926. 

  927. #if defined (LOSING_GCC_DESTRUCTOR_FREE_BUG)
    928. 

  928.   /* Prior to XEmacs 21, this was `#if 0'ed out.  */
    929. 

  929.   /* I'm enabling this because it is the only reliable way I've found to */
    930. 

  930.   /* prevent a very annoying problem where GCC will attempt to free (3) */
    931. 

  931.   /* memory at exit() and cause a coredump. */
    932. 

  932.   init_free_hook ();
    933. 

  933. #endif
    934. 

  934. 

  935. #define SHEBANG_PROGNAME_LENGTH                                         \
    936. 

  936.   (int)((sizeof (WEXTSTRING (SHEBANG_PROGNAME)) - sizeof (WEXTSTRING (""))))
    937. 

  937. #define SHEBANG_EXE_PROGNAME_LENGTH			\
    938. 

  938.   (int)(sizeof (WEXTSTRING (SHEBANG_PROGNAME) WEXTSTRING (".exe"))	\
    939. 

  939.         - sizeof (WEXTSTRING ("")))
    940. 

  940. 

  941.   {
    942. 

  942.     int progname_len = wext_strlen (argv[0]);
    943. 

  943.     if (progname_len >= SHEBANG_PROGNAME_LENGTH)
    944. 

  944.       {
    945. 

  945. 	if (!wext_strcmp_ascii (argv[0] +
    946. 

  946. 				(progname_len - SHEBANG_PROGNAME_LENGTH),
    947. 

  947. 				SHEBANG_PROGNAME)
    948. 

  948. 	    /* Allow trailing .exe. Don't check it, it could also be
    949. 

  949. 	       .com.  */
    950. 

  950. 	    || (progname_len >= SHEBANG_EXE_PROGNAME_LENGTH && 
    951. 

  951. 		!wext_strncmp_ascii
    952. 

  952. 		(argv[0] + (progname_len - SHEBANG_EXE_PROGNAME_LENGTH),
    953. 

  953. 		 SHEBANG_PROGNAME,
    954. 

  954. 		 SHEBANG_PROGNAME_LENGTH)))
    955. 

  955. 	  {
    956. 

  956. 	    Wexttext **newarr = alloca_array (Wexttext *, argc + 2);
    957. 

  957. 	    int j;
    958. 

  958. 

  959. 	    newarr[0] = argv[0];
    960. 

  960. 	    newarr[1] = (Wexttext *) WEXTSTRING ("--script");
    961. 

  961. 	    for (j = 1; j < argc; ++j)
    962. 

  962. 	      {
    963. 

  963. 		newarr[j + 1] = argv[j];
    964. 

  964. 	      }
    965. 

  965. 	    argv = newarr;
    966. 

  966. 	    argc++;
    967. 

  967. 	  }
    968. 

  968.       }
    969. 

  969.   }
    970. 

  970. 

  971.   sort_args (argc, argv);
    972. 

  972. 

  973. #if 0 /* defined (_SCO_DS)
    974. 

  974. 	 #### Turn this off, we already have another SCO_DS hack in main().
    975. 

  975.       */
    976. 

  976.   environ = envp;
    977. 

  977. #endif
    978. 

  978. 

  979.   /* Record (approximately) where the stack begins.  */
    980. 

  980.   stack_bottom = &stack_bottom_variable;
    981. 

  981. 

  982. #ifdef USG_SHARED_LIBRARIES
    983. 

  983.   if (bss_end)
    984. 

  984.     brk ((void *) bss_end);
    985. 

  985. #endif
    986. 

  986. 

  987.   clearerr (stdin);
    988. 

  988. 

  989. #if defined (HAVE_MMAP) && defined (REL_ALLOC)
    990. 

  990.   /* ralloc can only be used if using the GNU memory allocator. */
    991. 

  991.   init_ralloc ();
    992. 

  992. #elif defined (REL_ALLOC) && !defined (DOUG_LEA_MALLOC)
    993. 

  993.   if (initialized)
    994. 

  994.     init_ralloc ();
    995. 

  995. #endif
    996. 

  996. 

  997. #ifdef HAVE_SOCKS
    998. 

  998.   if (initialized)
    999. 

  999.     SOCKSinit (argv[0]);
    1000. 

  1000. #endif /* HAVE_SOCKS */
    1001. 

  1001. 

  1002. #ifndef SYSTEM_MALLOC
    1003. 

  1003.   if (!initialized)
    1004. 

  1004.     /* Arrange to get warning messages as memory fills up.  */
    1005. 

  1005.     memory_warnings (0, malloc_warning);
    1006. 

  1006. #endif	/* not SYSTEM_MALLOC */
    1007. 

  1007. 

  1008. #ifdef SET_EMACS_PRIORITY
    1009. 

  1009.   if (emacs_priority != 0)
    1010. 

  1010.     nice (-emacs_priority);
    1011. 

  1011.   setuid (getuid ());
    1012. 

  1012. #endif /* SET_EMACS_PRIORITY */
    1013. 

  1013. 

  1014.   /* NOTE NOTE NOTE: Keep the following args in sync with the big list of
    1015. 

  1015.      arguments below in standard_args[], with the help text in startup.el,
    1016. 

  1016.      and with the list of non-clobbered variables near where pdump_load()
    1017. 

  1017.      is called! */
    1018. 

  1018. 

  1019.   /* Handle the -sd/--show-dump-id switch, which means show the hex dump_id
    1020. 

  1020.      and quit */
    1021. 

  1021.   if (argmatch (argv, argc, "-sd", "--show-dump-id", 0, NULL, &skip_args))
    1022. 

  1022.     {
    1023. 

  1023. #ifdef PDUMP
    1024. 

  1024.       printf ("%08x\n", dump_id);
    1025. 

  1025. #else
    1026. 

  1026.       printf ("Portable dumper not configured; -sd just forces exit.\n");
    1027. 

  1027. #endif
    1028. 

  1028.       exit (0);
    1029. 

  1029.     }
    1030. 

  1030. 

  1031.   /* Handle the -si/--show-inline-info switch, which means show the
    1032. 

  1032.      alignment and max size of the inline data and quit */
    1033. 

  1033.   if (argmatch (argv, argc, "-si", "--show-inline-info", 0, NULL, &skip_args))
    1034. 

  1034.     {
    1035. 

  1035. #if defined (PDUMP) && defined (DUMP_IN_EXEC) && !defined (WIN32_NATIVE)
    1036. 

  1036.       /* #### We really should check for sizeof (size_t) > sizeof (long) */
    1037. 

  1037.       printf ("%lu %lu\n", (unsigned long) dumped_data_max_size (),
    1038. 

  1038. 			   (unsigned long) dumped_data_align_offset ());
    1039. 

  1039. 

  1040. #else
    1041. 

  1041.       printf ("Portable dumper not configured for dumping into executable or windows native; -si just forces exit.\n");
    1042. 

  1042. #endif
    1043. 

  1043.       exit (0);
    1044. 

  1044.     }
    1045. 

  1045. 

  1046.   /* Handle the --no-dump-file/-nd switch, which means don't load the dump
    1047. 

  1047.      file (ignored when not using pdump) */
    1048. 

  1048.   if (argmatch (argv, argc, "-nd", "--no-dump-file", 0, NULL, &skip_args))
    1049. 

  1049.     nodumpfile = 1;
    1050. 

  1050. 

  1051.   /* Handle the -batch switch, which means don't do interactive display.  */
    1052. 

  1052.   if (argmatch (argv, argc, "-batch", "--batch", 0, NULL, &skip_args))
    1053. 

  1053.     {
    1054. 

  1054. #if 0 /* I don't think this is correct. */
    1055. 

  1055.       inhibit_autoloads = 1;
    1056. 

  1056. #endif
    1057. 

  1057.       noninteractive = 1;
    1058. 

  1058.     }
    1059. 

  1059. 

  1060.   {
    1061. 

  1061.     int count_before = skip_args;
    1062. 

  1062.     /* Handle the -script switch, which implies batch and vanilla. The -l
    1063. 

  1063.        part of its functionality is implemented in Lisp. */
    1064. 

  1064.     if (argmatch (argv, argc, "-script", "--script", 0, NULL,
    1065. 

  1065. 		  &skip_args))
    1066. 

  1066.       {
    1067. 

  1067. 	noninteractive = 1;
    1068. 

  1068. 	vanilla_inhibiting = 1;
    1069. 

  1069.       }
    1070. 

  1070. 

  1071.     /* Don't actually discard this argument. */
    1072. 

  1072.     skip_args = count_before;
    1073. 

  1073.   }
    1074. 

  1074. #ifdef WIN32_NATIVE
    1075. 

  1075.   {
    1076. 

  1076.     /* Since we aren't a console application, we can't easily be terminated
    1077. 

  1077.        using ^C. (We aren't a console application to avoid Windows from
    1078. 

  1078.        automatically and unwantedly creating a console window for us.  If
    1079. 

  1079.        only the Windows designers had some sense in them and didn't create
    1080. 

  1080.        this artificial console/non-console distinction!) Therefore, we set
    1081. 

  1081.        up a communication path with i.exe so that when a ^C is sent to it
    1082. 

  1082.        (using GenerateConsoleCtrlEvent), it in turn signals us to commit
    1083. 

  1083.        suicide. (This is cleaner than using TerminateProcess()).  This
    1084. 

  1084.        makes (e.g.) the "Stop Build" command from VC++ correctly terminate
    1085. 

  1085.        XEmacs. */
    1086. 

  1086. 

  1087.     Wexttext *heventstr;
    1088. 

  1088.     if (argmatch (argv, argc, "-mswindows-termination-handle", 0, 0,
    1089. 

  1089. 		  &heventstr, &skip_args))
    1090. 

  1090.       {
    1091. 

  1091. 	HANDLE hevent = (HANDLE) wext_atol (heventstr);
    1092. 

  1092. 	DWORD unused;
    1093. 

  1093. 	HANDLE h_thread = CreateThread (NULL, 0, wait_for_termination_signal,
    1094. 

  1094. 					(void *) hevent, 0, &unused);
    1095. 

  1095. 	CloseHandle (h_thread);
    1096. 

  1096.       }
    1097. 

  1097.   }
    1098. 

  1098. 

  1099.   /* Handle the -nuni switch, which forces XEmacs to use the ANSI
    1100. 

  1100.      versions of Unicode-split API's even on Windows NT, which has
    1101. 

  1101.      full Unicode support.  This helps flush out problems in the code
    1102. 

  1102.      we've written to convert between ANSI and Unicode. */
    1103. 

  1103.   if (argmatch (argv, argc, "-nuni", "--no-unicode-lib-calls", 0, NULL,
    1104. 

  1104. 		&skip_args))
    1105. 

  1105.     no_mswin_unicode_lib_calls = 1;
    1106. 

  1106. #endif /* WIN32_NATIVE */
    1107. 

  1107. 

  1108.   if (argmatch (argv, argc, "-debug-paths", "--debug-paths",
    1109. 

  1109. 		0, NULL, &skip_args))
    1110. 

  1110.     debug_paths = 1;
    1111. 

  1111. 

  1112.   /* Handle (maybe partially) some inhibiting flags.  Packages are searched
    1113. 

  1113.      prior to the rest of the command line being parsed in startup.el. */
    1114. 

  1114. 

  1115.   if (argmatch (argv, argc, "-no-packages", "--no-packages",
    1116. 

  1116. 		0, NULL, &skip_args))
    1117. 

  1117.     {
    1118. 

  1118.       inhibit_all_packages = 1;
    1119. 

  1119.       inhibit_early_packages = 1;
    1120. 

  1120.       vanilla_inhibiting = 1;
    1121. 

  1121.     }
    1122. 

  1122. 

  1123.   if (argmatch (argv, argc, "-no-early-packages", "--no-early-packages",
    1124. 

  1124. 		0, NULL, &skip_args))
    1125. 

  1125.     inhibit_early_packages = 1;
    1126. 

  1126. 

  1127. #ifdef HAVE_SHLIB
    1128. 

  1128.   if (argmatch (argv, argc, "-no-site-modules", "--no-site-modules",
    1129. 

  1129. 		0, NULL, &skip_args))
    1130. 

  1130. #endif
    1131. 

  1131.     inhibit_site_modules = 1;
    1132. 

  1132. 

  1133.   if (argmatch (argv, argc, "-vanilla", "--vanilla",
    1134. 

  1134. 		0, NULL, &skip_args))
    1135. 

  1135.     {
    1136. 

  1136.       inhibit_early_packages = 1;
    1137. 

  1137.       vanilla_inhibiting = 1;
    1138. 

  1138.     }
    1139. 

  1139. 

  1140.   if (argmatch (argv, argc, "-no-autoloads", "--no-autoloads",
    1141. 

  1141. 		0, NULL, &skip_args))
    1142. 

  1142.     {
    1143. 

  1143.       inhibit_autoloads = 1;
    1144. 

  1144.       inhibit_early_packages = 1;
    1145. 

  1145.       vanilla_inhibiting = 1;
    1146. 

  1146.     }
    1147. 

  1147. 

  1148.   /* Partially handle the -version and -help switches: they imply -batch,
    1149. 

  1149.      but are not removed from the list. */
    1150. 

  1150.   if (argmatch (argv, argc, "-help", "--help",   3, NULL, &skip_args))
    1151. 

  1151.     noninteractive = 1, skip_args--;
    1152. 

  1152. 

  1153.   if (argmatch (argv, argc, "-version", "--version", 3, NULL, &skip_args) ||
    1154. 

  1154.       argmatch (argv, argc, "-V",    0,              2, NULL, &skip_args))
    1155. 

  1155.       noninteractive = 1, skip_args--;
    1156. 

  1156. 

  1157.   /* Now, figure out which type of console is our first console. */
    1158. 

  1158. 

  1159.   if (noninteractive)
    1160. 

  1160.     display_use = "stream";
    1161. 

  1161. 

  1162.   if (argmatch (argv, argc, "-nw", "--no-windows", 0, NULL, &skip_args) ||
    1163. 

  1163.       argmatch (argv, argc, "-tty", "--use-tty", 0, NULL, &skip_args))
    1164. 

  1164.     {
    1165. 

  1165.       check_compatible_window_system ("tty");
    1166. 

  1166. #ifndef HAVE_TTY
    1167. 

  1167.       fatal ("Sorry, this XEmacs was not compiled with TTY support");
    1168. 

  1168. #endif
    1169. 

  1169.     }
    1170. 

  1170. 

  1171.   if (argmatch (argv, argc, "-x", "--use-x", 0, NULL, &skip_args))
    1172. 

  1172.     {
    1173. 

  1173.       check_compatible_window_system ("x");
    1174. 

  1174. #ifndef HAVE_X_WINDOWS
    1175. 

  1175.       fatal ("Sorry, this XEmacs was not compiled with X support");
    1176. 

  1176. #endif
    1177. 

  1177.     }
    1178. 

  1178. 

  1179.   if (argmatch (argv, argc, "-gtk", "--use-gtk", 0, NULL, &skip_args) ||
    1180. 

  1180.       argmatch (argv, argc, "-gnome", "--use-gnome", 0, NULL, &skip_args))
    1181. 

  1181.     {
    1182. 

  1182.       check_compatible_window_system ("gtk");
    1183. 

  1183. #ifndef HAVE_GTK
    1184. 

  1184.       fatal ("Sorry, this XEmacs was not compiled with GTK support");
    1185. 

  1185. #endif
    1186. 

  1186.     }
    1187. 

  1187. 

  1188.   if (argmatch (argv, argc, "-msw", "--use-ms-windows", 0, NULL, &skip_args))
    1189. 

  1189.     {
    1190. 

  1190.       check_compatible_window_system ("mswindows");
    1191. 

  1191. #ifndef HAVE_MS_WINDOWS
    1192. 

  1192.       fatal ("Sorry, this XEmacs was not compiled with MS Windows support");
    1193. 

  1193. #endif
    1194. 

  1194.     }
    1195. 

  1195. 

  1196.   /* Handle other switches implying particular window systems: */
    1197. 

  1197. 

  1198.   /* Handle the -t switch, which specifies filename to use as terminal */
    1199. 

  1199.   {
    1200. 

  1200.     Wexttext *term;
    1201. 

  1201.     if (argmatch (argv, argc, "-t", "--terminal", 0, &term, &skip_args))
    1202. 

  1202.       {
    1203. 

  1203. 	int fd;
    1204. 

  1204. 

  1205. 	check_compatible_window_system ("tty");
    1206. 

  1206. #ifndef HAVE_TTY
    1207. 

  1207. 	fatal ("Sorry, this XEmacs was not compiled with TTY support");
    1208. 

  1208. #endif
    1209. 

  1209. 

  1210. 	retry_close (0);
    1211. 

  1211. 	retry_close (1);
    1212. 

  1212. 

  1213. 	fd = wext_retry_open (term, O_RDWR | OPEN_BINARY, 2);
    1214. 

  1214. 	/* Conversions are not possible yet, and printing will be in
    1215. 

  1215. 	   external format, so strerror() and ttyname() are OK. */
    1216. 

  1216. 	if (fd < 0 || dup (0) < 0)
    1217. 

  1217. 	  fatal ("%s: %s", WEXTTEXT_TO_8_BIT (term), strerror (errno));
    1218. 

  1218. 	if (! isatty (0))
    1219. 

  1219. 	  fatal ("%s: not a tty", WEXTTEXT_TO_8_BIT (term));
    1220. 

  1220. 

  1221. #if 0
    1222. 

  1222. 	stderr_out ("Using %s", ttyname (0));
    1223. 

  1223. #endif
    1224. 

  1224. 	stderr_out ("Using %s", WEXTTEXT_TO_8_BIT (term));
    1225. 

  1225.       }
    1226. 

  1226.   }
    1227. 

  1227. 

  1228.   /* Stupid kludge to catch command-line display spec.  We can't
    1229. 

  1229.      handle this argument entirely in window-system-dependent code
    1230. 

  1230.      because we don't even know which window-system-dependent code
    1231. 

  1231.      to run until we've recognized this argument.  */
    1232. 

  1232.   {
    1233. 

  1233. #ifdef HAVE_X_WINDOWS
    1234. 

  1234.     Wexttext *dpy = 0;
    1235. 

  1235.     int count_before = skip_args;
    1236. 

  1236. 

  1237.     if (argmatch (argv, argc, "-d", "--display", 3, &dpy, &skip_args) ||
    1238. 

  1238. 	argmatch (argv, argc, "-display", 0,     3, &dpy, &skip_args))
    1239. 

  1239.       {
    1240. 

  1240. 	check_compatible_window_system ("x");
    1241. 

  1241. 	display_arg = 1;
    1242. 

  1242.       }
    1243. 

  1243.       /* If we have the form --display=NAME,
    1244. 

  1244. 	 convert it into  -d name.
    1245. 

  1245. 	 This requires inserting a new element into argv.  */
    1246. 

  1246.       if (dpy != 0 && skip_args - count_before == 1)
    1247. 

  1247. 	{
    1248. 

  1248. 	  Wexttext **new_ = xnew_array (Wexttext *, argc + 2);
    1249. 

  1249. 	  int j;
    1250. 

  1250. 

  1251. 	  for (j = 0; j < count_before + 1; j++)
    1252. 

  1252. 	    new_[j] = argv[j];
    1253. 

  1253. 	  new_[count_before + 1] = (Wexttext *) WEXTSTRING ("-d");
    1254. 

  1254. 	  new_[count_before + 2] = dpy;
    1255. 

  1255. 	  for (j = count_before + 2; j <argc; j++)
    1256. 

  1256. 	    new_[j + 1] = argv[j];
    1257. 

  1257. 	  argv = new_;
    1258. 

  1258. 	  argc++;
    1259. 

  1259. 	}
    1260. 

  1260.       /* Change --display to -d, when its arg is separate.  */
    1261. 

  1261.       else if (dpy != 0 && skip_args > count_before
    1262. 

  1262. 	       && argv[count_before + 1][1] == '-')
    1263. 

  1263. 	argv[count_before + 1] = (Wexttext *) WEXTSTRING ("-d");
    1264. 

  1264. 

  1265.       /* Don't actually discard this arg.  */
    1266. 

  1266.       skip_args = count_before;
    1267. 

  1267. #endif /* HAVE_X_WINDOWS */
    1268. 

  1268.   }
    1269. 

  1269. 

  1270.   /* If no switch telling us which window system to use, try other
    1271. 

  1271.      possibilities: */
    1272. 

  1272. 

  1273. #if defined (HAVE_X_WINDOWS) || defined (HAVE_GTK)
    1274. 

  1274.   if (!display_use)
    1275. 

  1275.     {
    1276. 

  1276.       Wexttext *dpy;
    1277. 

  1277.       /* If there is a non-empty environment var DISPLAY, assume X or GTK,
    1278. 

  1278. 	 but don't set `display_arg', which is only to be set if the
    1279. 

  1279. 	 display was specified on the command line. */
    1280. 

  1280.       if ((dpy = wext_getenv (WEXTSTRING ("DISPLAY"))) && dpy[0])
    1281. 

  1281. #ifdef HAVE_X_WINDOWS
    1282. 

  1282. 	/* #### Who gets precedence?  X or GTK?  For the moment, GTK support is
    1283. 

  1283. 	   unstable so use X.  Maybe eventually we will switch this. */
    1284. 

  1284. 	display_use = "x";
    1285. 

  1285. #else
    1286. 

  1286. 	display_use = "gtk";
    1287. 

  1287. #endif
    1288. 

  1288.     }
    1289. 

  1289. #endif /* defined (HAVE_X_WINDOWS) || defined (HAVE_GTK) */
    1290. 

  1290. 

  1291. #ifdef HAVE_MS_WINDOWS
    1292. 

  1292.   if (!display_use)
    1293. 

  1293.     display_use = "mswindows";
    1294. 

  1294. #endif /* HAVE_MS_WINDOWS */
    1295. 

  1295. 

  1296. #ifdef HAVE_TTY
    1297. 

  1297.   if (!display_use)
    1298. 

  1298.     display_use = "tty";
    1299. 

  1299. #endif /* HAVE_MS_WINDOWS */
    1300. 

  1300. 

  1301.   if (!display_use)
    1302. 

  1302.     fatal ("No window systems and no TTY's in this XEmacs: Must specify "
    1303. 

  1303. 	   "-batch");
    1304. 

  1304. 

  1305.   noninteractive1 = noninteractive;
    1306. 

  1306. 

  1307.   /****** Now initialize everything *******/
    1308. 

  1308. 

  1309.   /* NOTE NOTE NOTE:
    1310. 

    1311. 

  1311.      In the code below, there are three different states we are concerned
    1312. 

  1312.      about:
    1313. 

    1314. 

  1314.      "raw-temacs" == No dumped Lisp data present.  `temacs', or (with pdump)
    1315. 

  1315.                      `xemacs -nd'.
    1316. 

    1317. 

  1317.      "run-temacs" == We are restarting.  run-emacs-from-temacs is called,
    1318. 

  1318.                      aka `run-temacs' on the command line.
    1319. 

    1320. 

  1320.      "post-dump"  == We are running an unexec()ed XEmacs, or we have loaded
    1321. 

  1321.                      dump data using pdump_load().
    1322. 

    1323. 

  1323.      initialized==0 => raw-temacs
    1324. 

  1324.      initialized!=0 && restart!=0 => run-temacs
    1325. 

  1325.      initialized!=0 && restart==0 => post-dump
    1326. 

    1327. 

  1327.      When post-pdump_load(), we need to reinitialize various structures.
    1328. 

  1328.      This case is noted in the code below by
    1329. 

    1330. 

  1330.        initialized +
    1331. 

  1331.        !restart +
    1332. 

  1332.        ifdef PDUMP.
    1333. 

    1334. 

  1334.      In the comments below, "dump time" or "dumping" == raw-temacs.
    1335. 

  1335.      "run time" == run-temacs or post-dump.
    1336. 

  1336. */
    1337. 

  1337. 

  1338.   /* First, do really basic environment initialization -- catching signals
    1339. 

  1339.      and the like.  These functions have no dependence on any part of
    1340. 

  1340.      the Lisp engine and need to be done both at dump time and at run time. */
    1341. 

  1341. 

  1342.   init_signals_very_early ();
    1343. 

  1343. #ifdef NEW_GC
    1344. 

  1344.   vdb_install_signal_handler ();
    1345. 

  1345. #endif /* NEW_GC */
    1346. 

  1346.   init_data_very_early (); /* Catch math errors. */
    1347. 

  1347.   init_floatfns_very_early (); /* Catch floating-point math errors. */
    1348. 

  1348.   init_process_times_very_early (); /* Initialize our process timers.
    1349. 

  1349. 				       As early as possible, of course,
    1350. 

  1350. 				       so we can be fairly accurate. */
    1351. 

  1351. 

  1352. #ifdef HAVE_MS_WINDOWS
    1353. 

  1353.   /* Depends on XEUNICODE_P */
    1354. 

  1354.   init_mswindows_dde_very_early (); /* DDE needs to be initialized early so
    1355. 

  1355. 				       that the client doesn't give up
    1356. 

  1356. 				       waiting.  */
    1357. 

  1357. #endif
    1358. 

  1358. 

  1359.   /* Now initialize the Lisp engine and the like.  Done only during
    1360. 

  1360.      dumping.  No dependence on anything that may be in the user's
    1361. 

  1361.      environment when the dumped XEmacs is run.
    1362. 

    1363. 

  1363.      We try to do things in an order that minimizes the non-obvious
    1364. 

  1364.      dependencies between functions. */
    1365. 

  1365. 

  1366.   /* purify_flag is set to indicate we are dumping (its name refers to
    1367. 

  1367.      purespace, which no longer exists and was a way of marking some
    1368. 

  1368.      areas read-only so they could be shared among many processes).
    1369. 

    1370. 

  1370.      loadup.el will set to nil at end. */
    1371. 

  1371. 

  1372.   purify_flag = 0;
    1373. 

  1373. #ifdef PDUMP
    1374. 

  1374.   in_pdump = 0;
    1375. 

  1375.   if (restart)
    1376. 

  1376.     initialized = 1;
    1377. 

  1377.   else if (nodumpfile)
    1378. 

  1378.     {
    1379. 

  1379.       initialized = 0;
    1380. 

  1380.       purify_flag = 1;
    1381. 

  1381.     }
    1382. 

  1382.   else
    1383. 

  1383.     {
    1384. 

  1384. 

  1385.       /* Keep command options from getting stomped.
    1386. 

    1387. 

  1387.       Some LISP-visible options are changed by XEmacs _after_ the data is
    1388. 

  1388.       dumped in building a --pdump XEmacs, but _before_ it is restored in
    1389. 

  1389.       normal operation.  Thus the restored values overwrite the values
    1390. 

  1390.       XEmacs is getting at run-time.  Such variables must be saved here,
    1391. 

  1391.       and restored after loading the dumped data.
    1392. 

    1393. 

  1393.       (Remember: Only LISP-visible options that are set up to this point
    1394. 

  1394.       need to be listed here.)
    1395. 

  1395.       */
    1396. 

  1396. 

  1397.       /* noninteractive1 is saved in noninteractive, which isn't
    1398. 

  1398. 	 LISP-visible */
    1399. 

  1399.       int inhibit_early_packages_save = inhibit_early_packages;
    1400. 

  1400.       int inhibit_autoloads_save      = inhibit_autoloads;
    1401. 

  1401.       int inhibit_all_packages_save   = inhibit_all_packages;
    1402. 

  1402.       int vanilla_inhibiting_save     = vanilla_inhibiting;
    1403. 

  1403.       int debug_paths_save            = debug_paths;
    1404. 

  1404.       int inhibit_site_lisp_save      = inhibit_site_lisp;
    1405. 

  1405.       int inhibit_site_modules_save   = inhibit_site_modules;
    1406. 

  1406. 

  1407.       initialized = pdump_load (argv[0]);
    1408. 

  1408. 

  1409.       /* Now unstomp everything */
    1410. 

  1410.       noninteractive1        = noninteractive;
    1411. 

  1411.       inhibit_early_packages = inhibit_early_packages_save;
    1412. 

  1412.       inhibit_autoloads      = inhibit_autoloads_save;
    1413. 

  1413.       inhibit_all_packages   = inhibit_all_packages_save;
    1414. 

  1414.       vanilla_inhibiting     = vanilla_inhibiting_save;
    1415. 

  1415.       debug_paths            = debug_paths_save;
    1416. 

  1416.       inhibit_site_lisp      = inhibit_site_lisp_save;
    1417. 

  1417.       inhibit_site_modules   = inhibit_site_modules_save;
    1418. 

  1418. 

  1419.       if (initialized)
    1420. 

  1420. 	run_temacs_argc = -1;
    1421. 

  1421.       else
    1422. 

  1422. 	purify_flag = 1;
    1423. 

  1423.     }
    1424. 

  1424. #else /* not PDUMP */
    1425. 

  1425.   if (!initialized)
    1426. 

  1426.     purify_flag = 1;
    1427. 

  1427. #endif
    1428. 

  1428. 

  1429.   init_alloc_early ();
    1430. 

  1430. 

  1431.   init_gc_early ();
    1432. 

  1432. 

  1433.   if (!initialized)
    1434. 

  1434.     {
    1435. 

  1435.       /* Initialize things so that new Lisp objects
    1436. 

  1436. 	 can be created and objects can be staticpro'd.
    1437. 

  1437. 	 Must be basically the very first thing done
    1438. 

  1438. 	 because pretty much all of the initialization
    1439. 

  1439. 	 routines below create new objects. */
    1440. 

  1440.       init_alloc_once_early ();
    1441. 

  1441. 

  1442.       init_gc_once_early ();
    1443. 

  1443. 

  1444.       /* Initialize Qnil, Qt, Qunbound, and the
    1445. 

  1445. 	 obarray.  After this, symbols can be
    1446. 

  1446. 	 interned.  This depends on init_alloc_once_early(). */
    1447. 

  1447.       init_symbols_once_early ();
    1448. 

  1448. 

  1449.       /* Declare the basic symbols pertaining to errors,
    1450. 

  1450. 	 So that DEFERROR*() can be called. */
    1451. 

  1451.       init_errors_once_early ();
    1452. 

  1452. 

  1453.       /* Make sure that opaque pointers can be created. */
    1454. 

  1454.       init_opaque_once_early ();
    1455. 

  1455. 

  1456.       /* Make sure that hash tables can be created. */
    1457. 

  1457.       init_elhash_once_early ();
    1458. 

  1458. 

  1459.       /* Make sure that eistrings can be crea…
    1460.

Large files files are truncated, but you can click here to view the full file