#+AUTHOR: Sigmund Tzeng

* synopsis
#+BEGIN_SRC sh

node js/temacs-24.5.js js/loadup_1.el         # first list; working!!
node js/temacs-24.5.js js/loadup.el           # benchmark; shall work finally
#+END_SRC 
以上指令將載入 emacs 預載的 loadup.el 並進行 sanity check ，驗證 temacs 的完成度。

接下來的工作，將分為兩個方向進行。 從 mal 方找尋 emacs 方的對應元素，以及從 emacs 的執行期行為找尋對應的程式以決定實作的優先順序。

* 從 emacs 的執行期行為找尋對應的程式碼
程式執行開頭頭有顯示一個 splash 畫面，我們將從此畫面的元素著手，得到初始載入順序相關資訊。

startup.el 是第一個被載入執行的 lisp 檔案。 經分析後發現此一行為由 Makefile.in 所指定。

** building
*** bare emacs: Emacs Lisp interpreter and I/O routines
 [[bookmark:temacs][Bookmark: temacs]]

 在建置 emacs 的過程中，第一步為產生此一空殼 temacs 

*** dumped (pure) Emacs: set up the normal Emacs editing environment

 [[bookmark:dumped%20Emacs][Bookmark: dumped Emacs]]

 c.f. 末傾印，只進行 "拔靴法(Bootstrap)" 
 [[bookmark:bootstrap-emacs][Bookmark: bootstrap-emacs]]

 在建置 emacs 的過程中，第二步為產生此一 "dumped Emacs" 的預載映象檔；其 --load 參數指定了 loadup.el 這個預載檔案；其中 loadup.el 會再指定預載檔案
**** load "startup"
 [[bookmark:load%20"startup"][Bookmark: load "startup"]]

 在此檔末端並指定執行 startup.el 中的 top-level 函數，也就是 normal-top-level。 

startup.el 有特定的字串，似乎與視窗介面的建立有關。

其它載入檔案如下：

 (load "emacs-lisp/byte-run")
 (load "emacs-lisp/backquote")
 (load "subr")
 (load "version")
 (load "widget")
 (load "custom")
 (load "emacs-lisp/map-ynp")
 (load "international/mule")
 (load "international/mule-conf")
 (load "env")
 (load "format")
 (load "bindings")
 (load "cus-start")
 (load "window")  ; Needed here for `replace-buffer-in-windows'.
 (load "files")
 (load "emacs-lisp/macroexp")
     (load "emacs-lisp/pcase"))
   (load "emacs-lisp/macroexp"))
 (load "cus-face")
 (load "faces")  ; after here, `defface' may be used.
 (load "button")

 (load "startup")

     (load "loaddefs.el")
   (file-error (load "ldefs-boot.el")))
 (load "emacs-lisp/nadvice")
 (load "minibuffer")
 (load "abbrev")         ;lisp-mode.el and simple.el use define-abbrev-table.
 (load "simple")
 (load "help")
 (load "jka-cmpr-hook")
 (load "epa-hook")
 (load "international/mule-cmds")
 (load "case-table")
 (load "international/charprop.el" t)
 (load "international/characters")
 (load "composite")
 (load "language/chinese")
 (load "language/cyrillic")
 (load "language/indian")
 (load "language/sinhala")
 (load "language/english")
 (load "language/ethiopic")
 (load "language/european")
 (load "language/czech")
 (load "language/slovak")
 (load "language/romanian")
 (load "language/greek")
 (load "language/hebrew")
 (load "language/japanese")
 (load "language/korean")
 (load "language/lao")
 (load "language/tai-viet")
 (load "language/thai")
 (load "language/tibetan")
 (load "language/vietnamese")
 (load "language/misc-lang")
 (load "language/utf-8-lang")
 (load "language/georgian")
 (load "language/khmer")
 (load "language/burmese")
 (load "language/cham")
 (load "indent")
 (load "frame")
 (load "term/tty-colors")
 (load "font-core")
 (load "facemenu")
 (load "emacs-lisp/syntax")
 (load "font-lock")
 (load "jit-lock")
       (load "mouse")
	    (load "scroll-bar"))
       (load "select")))
 (load "emacs-lisp/timer")
 (load "isearch")
 (load "rfn-eshadow")
 (load "menu-bar")
 (load "emacs-lisp/lisp")
 (load "textmodes/page")
 (load "register")
 (load "textmodes/paragraphs")
 (load "progmodes/prog-mode")
 (load "emacs-lisp/lisp-mode")
 (load "textmodes/text-mode")
 (load "textmodes/fill")
 (load "newcomment")
 (load "replace")
 (load "emacs-lisp/tabulated-list")
 (load "buff-menu")
       (load "fringe")
       (load "emacs-lisp/regexp-opt")
       (load "image")
       (load "international/fontset")
       (load "dnd")
       (load "tool-bar")))
     (load "dynamic-setting"))
       (load "x-dnd")
       (load "term/common-win")
       (load "term/x-win")))
       (load "term/common-win")
       (load "w32-vars")
       (load "term/w32-win")
       (load "disp-table")
       (load "w32-common-fns")
         (load "w32-fns")
         (load "ls-lisp")
         (load "dos-w32"))))
       (load "dos-w32")
       (load "dos-fns")
       (load "dos-vars")
       (load "term/internal")
       (load "term/pc-win")
       (load "ls-lisp")
       (load "disp-table"))) ; needed to setup ibm-pc char set, see internal.el
       (load "term/common-win")
       (load "term/ns-win")))
     (load "mwheel"))
 (load "emacs-lisp/float-sup")
 (load "vc/vc-hooks")
 (load "vc/ediff-hook")
 (load "uniquify")
 (load "electric")
 (if (not (eq system-type 'ms-dos)) (load "tooltip"))
 (load "leim/leim-list.el" t)
   (load "site-load" t)
   (load "site-init" t)
*** daily emacs, finally
 [[bookmark:Unless%20next%20switch%20is%20-nl,%20load%20"loadup.el"%20first%20thing.][Bookmark: Unless next switch is -nl, load "loadup.el" first thing.]]

 Unless next switch is -nl, load "loadup.el" first thing.
** running


*** 初始化@main()@emacs.c: initXXX & syms_of_XXX (defsubr, DEFVAR & DEFSYM)

**** init_obarray (object array = Vobarray)
[[bookmark:init_obarray%20(void)][Bookmark: init_obarray (void)]]

obarray 就是 object array 的意思，object 的型態都是 Lisp_Object

initial_obarray 是最初始的物件陣列，包含了最開始的三個常量： Qt, Qnil, Qunbound

最陽春的符號就是 Qt ，其定義代表最低要求 intern_c_string & SET_SYMBOL_VAL
***** Qt: "t"
#+BEGIN_SRC C
Qt = intern_c_string ("t");
SET_SYMBOL_VAL (XSYMBOL (Qt), Qt);
XSYMBOL (Qt)->constant = 1;
#+END_SRC

***** Qnil: "nil"
#+BEGIN_SRC C
  /* Set temporary dummy values to Qnil and Vpurify_flag to satisfy the
     NILP (Vpurify_flag) check in intern_c_string.  */
  Qnil = make_number (-1); Vpurify_flag = make_number (1);
  Qnil = intern_c_string ("nil");
  SET_SYMBOL_VAL (XSYMBOL (Qnil), Qnil);
  XSYMBOL (Qnil)->constant = 1;
  XSYMBOL (Qnil)->declared_special = 1;
  set_symbol_plist (Qnil, Qnil);
  set_symbol_function (Qnil, Qnil);

  XSYMBOL (Qnil)->declared_special = 1;
#+END_SRC

***** Qunbound: "unbound"
#+BEGIN_SRC C
  Qunbound = Fmake_symbol (build_pure_c_string ("unbound"));
  /* Fmake_symbol inits fields of new symbols with Qunbound and Qnil,
     so those two need to be fixed manually.  */
  SET_SYMBOL_VAL (XSYMBOL (Qunbound), Qunbound);
  set_symbol_function (Qunbound, Qnil);
  set_symbol_plist (Qunbound, Qnil);
#+END_SRC

**** init_XXX: 以 Vcommand_line_args 為例
[[bookmark:init_cmdargs%20(argc,%20argv,%20skip_args,%20original_pwd);][Bookmark: init_cmdargs (argc, argv, skip_args, original_pwd);]]

[[bookmark:init_cmdargs%20(int%20argc,%20char%20**argv,%20int%20skip_args,%20char%20*original_pwd)][Bookmark: init_cmdargs (int argc, char **argv, int skip_args, char *original_pwd)]]

[[bookmark:Fcons%20(build_unibyte_string%20(argv%5Bi%5D),%20Vcommand_line_args);][Bookmark: Fcons (build_unibyte_string (argv{i}), Vcommand_line_args);]]

#+BEGIN_SRC C
  Vcommand_line_args = Qnil;

  for (i = argc - 1; i >= 0; i--)
    {
      if (i == 0 || i > skip_args)
	/* For the moment, we keep arguments as is in unibyte strings.
	   They are decoded in the function command-line after we know
	   locale-coding-system.  */
	Vcommand_line_args
	  = Fcons (build_unibyte_string (argv[i]), Vcommand_line_args);
    }
#+END_SRC

**** DEFVAR in syms_of_emacs ()
[[bookmark:syms_of_emacs%20();][Bookmark: syms_of_emacs ();]]

[[bookmark:void%20syms_of_emacs%20(void)][Bookmark: void syms_of_emacs (void)]]

[[bookmark:DEFVAR_LISP%20("command-line-args",%20Vcommand_line_args,][Bookmark: DEFVAR_LISP ("command-line-args", Vcommand_line_args,]]

#+BEGIN_SRC C
  DEFVAR_LISP ("command-line-args", Vcommand_line_args,
	       doc: /* Args passed by shell to Emacs, as a list of strings.
Many arguments are deleted from the list as they are processed.  */);
#+END_SRC

DEFVAR 的作用似乎是直接在 global 的 symbol table 中寫入一筆資料，作用比較單純

**** DEFVAR
***** DEFVAR_LISP @ lread.c
  [[bookmark:DEFVAR_LISP%20("command-line-args",%20Vcommand_line_args,][Bookmark: DEFVAR_LISP ("command-line-args", Vcommand_line_args,]]

  [[bookmark:#define%20DEFVAR_LISP(lname,%20vname,%20doc)][Bookmark: #define DEFVAR_LISP(lname, vname, doc)]]

#+BEGIN_SRC C
  /* Macros we use to define forwarded Lisp variables.
     These are used in the syms_of_FILENAME functions.

     An ordinary (not in buffer_defaults, per-buffer, or per-keyboard)
     lisp variable is actually a field in `struct emacs_globals'.  The
     field's name begins with "f_", which is a convention enforced by
     these macros.  Each such global has a corresponding #define in
     globals.h; the plain name should be used in the code.

     E.g., the global "cons_cells_consed" is declared as "int
     f_cons_cells_consed" in globals.h, but there is a define:

	#define cons_cells_consed globals.f_cons_cells_consed

     All C code uses the `cons_cells_consed' name.  This is all done
     this way to support indirection for multi-threaded Emacs.  */

  #define DEFVAR_LISP(lname, vname, doc)		\
    do {						\
      static struct Lisp_Objfwd o_fwd;		\
      defvar_lisp (&o_fwd, lname, &globals.f_ ## vname);		\
    } while (false)
#+END_SRC

  在執行最開始的 make 的過程中，所有 DEFVAR 的 vname 會被收集到 globals.h 當中， 成為 emacs_globasl 的一個欄位， 名稱會加上前綴 f_ , 然後又被巨集宣告為與 lname 同名的變數。
***** defvar_lisp @ lread.c
  由以下程式碼可看出，這些變數會存到 staticvec 這個陣列中， 這個部分與 gargabe collection 有關， 在此不詳述。 與 defsubr 的作法類似， 此變數的名稱會被註冊為一符號，並以 obarray 存放，方便以變數名查詢符號。 符號再經 SET_SYMBOL_FWD 存放此一變數的指標。

  [[bookmark:defvar_lisp%20(struct%20Lisp_Objfwd%20*o_fwd,][Bookmark: defvar_lisp (struct Lisp_Objfwd *o_fwd,]]

#+BEGIN_SRC C
  /* Similar but define a variable whose value is the Lisp Object stored
     at address.  Two versions: with and without gc-marking of the C
     variable.  The nopro version is used when that variable will be
     gc-marked for some other reason, since marking the same slot twice
     can cause trouble with strings.  */
  void
  defvar_lisp_nopro (struct Lisp_Objfwd *o_fwd,
		     const char *namestring, Lisp_Object *address)
  {
    Lisp_Object sym;
    sym = intern_c_string (namestring);
    o_fwd->type = Lisp_Fwd_Obj;
    o_fwd->objvar = address;
    XSYMBOL (sym)->declared_special = 1;
    XSYMBOL (sym)->redirect = SYMBOL_FORWARDED;
    SET_SYMBOL_FWD (XSYMBOL (sym), (union Lisp_Fwd *)o_fwd);
  }

  void
  defvar_lisp (struct Lisp_Objfwd *o_fwd,
	       const char *namestring, Lisp_Object *address)
  {
    defvar_lisp_nopro (o_fwd, namestring, address);
    staticpro (address);
  }
#+END_SRC
***** staticpro: garbage collection
  [[bookmark:staticpro%20(Lisp_Object%20*varaddress)][Bookmark: staticpro (Lisp_Object *varaddress)]]

#+BEGIN_SRC C
  /***********************************************************************
			    Protection from GC
   ***********************************************************************/

  /* Put an entry in staticvec, pointing at the variable with address
     VARADDRESS.  */

  void
  staticpro (Lisp_Object *varaddress)
  {
    if (staticidx >= NSTATICS)
      fatal ("NSTATICS too small; try increasing and recompiling Emacs.");
    staticvec[staticidx++] = varaddress;
  }
#+END_SRC
***** SET_SYMBOL_FWD
 [[bookmark:SET_SYMBOL_FWD%20(struct%20Lisp_Symbol%20*sym,%20union%20Lisp_Fwd%20*v)][Bookmark: SET_SYMBOL_FWD (struct Lisp_Symbol *sym, union Lisp_Fwd *v)]]

#+BEGIN_SRC C
 INLINE void
 SET_SYMBOL_FWD (struct Lisp_Symbol *sym, union Lisp_Fwd *v)
 {
   eassert (sym->redirect == SYMBOL_FORWARDED);
   sym->val.fwd = v;
 }
#+END_SRC
***** SYMBOL_FORWARDED 影響到的函數
****** specbind
 特重要！！！ lisp 中的這些函數也需要它： let, 以及因為實質上使用了 let 而以 C 改寫的函數
****** 其它
******* buffer_local_value_1
#+BEGIN_SRC C
  /* Return the value of VARIABLE in BUFFER.
  If VARIABLE does not have a buffer-local binding in BUFFER, the value
  is the default binding of the variable. */
#+END_SRC
******* store_frame_param
******* mark_object

***** staticvec: 與 GC 有關，不重要

**** 兼論 expand-file-name
[[bookmark:EMACSLOADPATH=$(CURDIR)/../lisp][Bookmark: EMACSLOADPATH=$(CURDIR)/../lisp]]

#+BEGIN_SRC C
DEFUN ("expand-file-name", Fexpand_file_name, Sexpand_file_name, 1, 2, 0,
#+END_SRC





**** 小結： 復刻 emacs 初始化行為
*** C / Lisp 兩用函數的宣告/定義及登錄： DEFUN (& defsubr) @syms_of_XXX（）
以 if 這個函數來作為範例，它的宣告/定義是 DEFUN ("if", Fif, Sif, 2, UNEVALLED, 0 …

前面三個參數是最重要的， "if" 是它在 lisp 程式中的名稱， Fif 是在 C 程式碼中的名稱， 至於 Sif 可以看做是紀錄相關資訊的結構 （struct） 的名稱。

 [[bookmark:#define%20DEFUN(lname,%20fnname,%20sname,%20minargs,%20maxargs,%20intspec,%20doc)][Bookmark: #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc)]]

#+BEGIN_SRC C
#  define DEFUN_FUNCTION_INIT(fnname, maxargs) .a ## maxargs = fnname

#define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc)	\
   Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;				\
   static struct Lisp_Subr alignas (GCALIGNMENT) sname =		\
     { { PVEC_SUBR << PSEUDOVECTOR_AREA_BITS },				\
       { DEFUN_FUNCTION_INIT (fnname, maxargs) },			\
       minargs, maxargs, lname, intspec, 0};				\
   Lisp_Object fnname
#+END_SRC

sname 此一結構的 an 成員 (0<=n<=9) 即為 FXXX 形式的函數（指標？）

至於定義後要如何被 lisp 的程式碼找到並呼叫呢？ 這就需要以 defsubr 來登錄 Sif 結構了。 

**** defsubr (&SXXX); 將名稱加到 Vobarray 中、登錄 SXXX 結構

 [[bookmark:defsubr][Bookmark: defsubr]]
***** intern_c_string 
此函數首先呼叫了 intern_c_string 以登錄函數名稱為符號，並加到 Vobarray 中

[[bookmark:intern_c_string%20(const%20char%20*str)][Bookmark: intern_c_string (const char *str)]]

[[bookmark:intern_c_string_1%20(const%20char%20*str,%20ptrdiff_t%20len)][Bookmark: intern_c_string_1 (const char *str, ptrdiff_t len)]]

#+BEGIN_SRC C
/* Intern the C string STR: return a symbol with that name,
   interned in the current Vobarray.  */


typedef EMACS_INT Lisp_Object;
#+END_SRC
***** XSETSUBR (tem, sname)
#+BEGIN_SRC C
#define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
#+END_SRC
***** set_symbol_function
然後呼叫 set_symbol_function 把符號和函數連結起來

[[bookmark:set_symbol_function%20(Lisp_Object%20sym,%20Lisp_Object%20function)][Bookmark: set_symbol_function (Lisp_Object sym, Lisp_Object function)]]


*** 為何沒有DEFCONST?DEFSYM的作用？
https://www.gnu.org/software/emacs/manual/html_node/elisp/Creating-Symbols.html#Creating-Symbols

**** func, subst, alias, macro

**** var, const, custom

*** REPL
在 main 函數中，呼叫了 Frecursive-edit ，這是事件處理迴圈的入口

[[bookmark:Frecursive_edit%20();][Bookmark: Frecursive_edit ();]]

[[bookmark:DEFUN%20("recursive-edit",%20Frecursive_edit,%20Srecursive_edit,%200,%200,%20"",][DEFUN ("recursive-edit", Frecursive_edit, Srecursive_edit, 0, 0, "",]]

[[bookmark:command_loop%20(void)][Bookmark: command_loop (void)]]

**** load "loadup.el" first thing
在進入 Frecursive-edit 之前，已經塞了指令 load loadup.el 給最上層的環境：

[[bookmark:Vtop_level%20=%20list2%20(intern_c_string%20("load"),][Bookmark: Vtop_level = list2 (intern_c_string ("load"),]]

因此先討論整個 eval 的入口

 [[bookmark:internal_catch%20(Qtop_level,%20top_level_1,%20Qnil);][Bookmark: internal_catch (Qtop_level, top_level_1, Qnil);]]

 [[bookmark:top_level_1%20(Lisp_Object%20ignore)][Bookmark: top_level_1 (Lisp_Object ignore)]]

 [[bookmark:internal_condition_case%20(top_level_2,%20Qerror,%20cmd_error);][Bookmark: internal_condition_case (top_level_2, Qerror, cmd_error);]]

 [[bookmark:top_level_2%20(void)][Bookmark: top_level_2 (void)]]

 [[bookmark:return%20Feval%20(Vtop_level,%20Qnil);][Bookmark: return Feval (Vtop_level, Qnil);]]

[[bookmark:DEFUN%20("eval",%20Feval,%20Seval,%201,%202,%200,][Bookmark: DEFUN ("eval", Feval, Seval, 1, 2, 0,]]

***** eval_sub
[[bookmark:return%20unbind_to%20(count,%20eval_sub%20(form));][Bookmark: return unbind_to (count, eval_sub (form));]]

[[bookmark:eval_sub%20(Lisp_Object%20form)][Bookmark: eval_sub (Lisp_Object form)]]

此處呼叫了 list 的函數以進行求值
#+BEGIN_SRC C
	  switch (i)
	    {
	    case 0:
	      val = (XSUBR (fun)->function.a0 ());
	      break;
	    case 1:
	      val = (XSUBR (fun)->function.a1 (argvals[0]));
	      break;
	    case 2:
	      val = (XSUBR (fun)->function.a2 (argvals[0], argvals[1]));
	      break;
	    case 3:
	      val = (XSUBR (fun)->function.a3
		     (argvals[0], argvals[1], argvals[2]));
	      break;
	    case 4:
	      val = (XSUBR (fun)->function.a4
		     (argvals[0], argvals[1], argvals[2], argvals[3]));
	      break;
	    case 5:
	      val = (XSUBR (fun)->function.a5
		     (argvals[0], argvals[1], argvals[2], argvals[3],
		      argvals[4]));
	      break;
	    case 6:
	      val = (XSUBR (fun)->function.a6
		     (argvals[0], argvals[1], argvals[2], argvals[3],
		      argvals[4], argvals[5]));
	      break;
	    case 7:
	      val = (XSUBR (fun)->function.a7
		     (argvals[0], argvals[1], argvals[2], argvals[3],
		      argvals[4], argvals[5], argvals[6]));
	      break;

	    case 8:
	      val = (XSUBR (fun)->function.a8
		     (argvals[0], argvals[1], argvals[2], argvals[3],
		      argvals[4], argvals[5], argvals[6], argvals[7]));
	      break;

	    default:
	      /* Someone has created a subr that takes more arguments than
		 is supported by this code.  We need to either rewrite the
		 subr to use a different argument protocol, or add more
		 cases to this switch.  */
	      emacs_abort ();
	    }
#+END_SRC
***** Fload(): Execute a file of Lisp code named FILE.
Fload() 雖然不是初級的語法元素，但是了解它的流程對測試有相當的幫助，因此以下說明它的執行流程

[[bookmark:DEFUN%20("load",%20Fload,%20Sload,%201,%205,%200,][Bookmark: DEFUN ("load", Fload, Sload, 1, 5, 0,]]

****** readevalloop
[[bookmark:readevalloop%20(Qget_file_char,%20stream,%20hist_file_name,][Bookmark: readevalloop (Qget_file_char, stream, hist_file_name,]]

[[bookmark:readevalloop%20(Lisp_Object%20readcharfun,][Bookmark: readevalloop (Lisp_Object readcharfun,]]

即然名為 ReadEval(Print)Loop = RE(P)L ，應該就會有個迴圈，進行讀取->求值。 

參數 stream 為所讀取檔案的 handle , 若為 nil 時表示由 stdin 讀取。

迴圈中以 READCHAR 來預讀一個字元，以判斷接下來的語法元素，並調用對應的函式

除了 read_list 以外，其它函數都還滿 trivial 的，因此以下集中討論 read_list

******* READCHAR
 [[bookmark:c%20=%20READCHAR;][Bookmark: c = READCHAR;]] 

 #define READCHAR readchar (readcharfun, NULL)

[[bookmark:static%20int%20readchar%20(Lisp_Object%20readcharfun,%20bool%20*multibyte)][Bookmark: static int readchar (Lisp_Object readcharfun, bool *multibyte)]]

/* When READCHARFUN is Qget_file_char, Qget_emacs_mule_file_char,
   Qlambda, or a cons, we use this to keep an unread character because
   a file stream can't handle multibyte-char unreading.  The value -1
   means that there's no unread character.  */

******* read_list
 [[bookmark:val%20=%20read_list%20(0,%20readcharfun);][Bookmark: val = read_list (0, readcharfun);]]

[[bookmark:static%20Lisp_Object%20read_list%20(bool%20flag,%20Lisp_Object%20readcharfun)][Bookmark: static Lisp_Object read_list (bool flag, Lisp_Object readcharfun)]]

******** read1
[[bookmark:elt%20=%20read1%20(readcharfun,%20&ch,%20first_in_list);][Bookmark: elt = read1 (readcharfun, &ch, first_in_list);]]

[[bookmark:static%20Lisp_Object%20read1%20(Lisp_Object%20readcharfun,%20int%20*pch,%20bool%20first_in_list)][Bookmark: static Lisp_Object read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)]]

******** Fintern
[[bookmark:result%20=%20(uninterned_symbol%20?%20Fmake_symbol%20(name)%20:%20Fintern%20(name,%20Qnil));][Bookmark: result = (uninterned_symbol ? Fmake_symbol (name) : Fintern (name, Qnil));]]

[[bookmark:DEFUN%20("intern",%20Fintern,%20Sintern,%201,%202,%200,][Bookmark: DEFUN ("intern", Fintern, Sintern, 1, 2, 0,]]

/* Return the canonical symbol whose name is STRING.
If there is none, one is created by this function and returned.
A second optional argument specifies the obarray to use;
it defaults to the value of `Vobarray'.  */

此一函數做的事基本上就跟 intern_c_string_1/intern_c_string 一樣，查詢此一字串是否已定義為符號，並傳回之

******* DEFUN ("macroexpand", Fmacroexpand, Smacroexpand, 1, 2, 0,
[[bookmark:DEFUN%20("macroexpand",%20Fmacroexpand,%20Smacroexpand,%201,%202,%200,][Bookmark: DEFUN ("macroexpand", Fmacroexpand, Smacroexpand, 1, 2, 0,]]

這個部分我滿懷疑是不是寫錯了，似乎永遠不會執行到？？

******* eval_sub
[[bookmark:val%20=%20eval_sub%20(val);][Bookmark: val = eval_sub (val);]]

此後由於 read_list 已經進行了實質上的 scanning ，而 emacs lisp 實質上就是 AST ，所以不需要 parsing

因此可以直接進行求值。
***** emacs lisp key syntax elements in eval.c
[[bookmark:syms_of_eval%20(void)][Bookmark: syms_of_eval (void)]]

****** conditionals
   defsubr (&Sor);
   defsubr (&Sand);
   defsubr (&Sif);
   defsubr (&Scond);

****** blocks
   defsubr (&Sprogn);
   defsubr (&Sprog1);
   defsubr (&Sprog2);

****** var
   defsubr (&Ssetq);
   defsubr (&Squote);
   defsubr (&Sfunction);
   defsubr (&Sdefault_toplevel_value);
   defsubr (&Sset_default_toplevel_value);
   defsubr (&Sdefvar);
   defsubr (&Sdefvaralias);
   defsubr (&Sdefconst);
   defsubr (&Smake_var_non_special);
   defsubr (&Slet);
   defsubr (&SletX);

****** macro
   defsubr (&Swhile);
   defsubr (&Smacroexpand);

****** exception
   defsubr (&Scatch);
   defsubr (&Sthrow);
   defsubr (&Sunwind_protect);

****** flow
   defsubr (&Scondition_case);
   defsubr (&Ssignal);
   defsubr (&Scommandp);
   defsubr (&Sautoload);
   defsubr (&Sautoload_do_load);
   defsubr (&Seval);
   defsubr (&Sapply);
   defsubr (&Sfuncall);

****** misc
   defsubr (&Srun_hooks);
   defsubr (&Srun_hook_with_args);
   defsubr (&Srun_hook_with_args_until_success);
   defsubr (&Srun_hook_with_args_until_failure);
   defsubr (&Srun_hook_wrapped);
   defsubr (&Sfetch_bytecode);
   defsubr (&Sbacktrace_debug);
   defsubr (&Sbacktrace);
   defsubr (&Sbacktrace_frame);
   defsubr (&Sbacktrace_eval);
   defsubr (&Sbacktrace__locals);
   defsubr (&Sspecial_variable_p);
   defsubr (&Sfunctionp);

**** UI
以下部分屬於使用者互動，在 repl 的層級暫不討論

 [[bookmark:command_loop_2%20(Lisp_Object%20ignore)][Bookmark: command_loop_2 (Lisp_Object ignore)]]

 [[bookmark:internal_condition_case%20(command_loop_1,%20Qerror,%20cmd_error);][Bookmark: internal_condition_case (command_loop_1, Qerror, cmd_error);]]




* 從 mal 方找尋 emacs 方的對應元素

** repl_env => Vobarray
mal 在初始化的過程中，把 core.ns 的內容複製到了 repl_env 當中，因此 repl_env 才是真正意義上存放所有 symboe 的物件，core.ns 則類似於 initial_obarray
** equal
嘗試載入 loadup.el 的過程中，第一個遇到的問題就是找不到這個算子。這個問題倒是好解決，因為 mal 本身已經定義了 "=" 算子；不過這倒是提供我們再一次審視 scanning / parsing 的流程

*** emacs implementation
fns.c  中有如下定義：

[[bookmark:DEFUN%20("equal",%20Fequal,%20Sequal,%202,%202,%200,][Bookmark: DEFUN ("equal", Fequal, Sequal, 2, 2, 0,]]

[[bookmark:%20%20defsubr%20(&Sequal);][Bookmark:   defsubr (&Sequal);]]
*** mal implementation
core.js 中有如下定義：

[[bookmark:var%20ns%20=%20{'type':%20types._obj_type,%20'=':%20types._equal_Q,][Bookmark: var ns = {'type': types._obj_type, '=': types._equal_Q,]]

因此符號的代表字串 '=' ，以及對應的函數 _equal_Q ，做為 hash 的一筆資料而存在於 ns 中

stepA_mal.js 中有如下定義：

[[bookmark:for%20(var%20n%20in%20core.ns)%20{%20repl_env.set(types._symbol(n),%20core.ns%5Bn%5D);%20}][Bookmark: for (var n in core.ns) { repl_env.set(types._symbol(n), core.ns{n}); }]]

ns 的資料再被逐筆的複製到 repl_env 中
*** 小結:  DEFUN/defsubr -> core.ns
** let* / let 

Note that there are plenty of ways to make (GLOBAL) bindings: ‘defconst’, ‘defun’, ‘defvar’, 'let', ‘flet’, ‘labels’, ‘prog’, etc.

根據 [[https://www.emacswiki.org/emacs/DynamicBindingVsLexicalBinding][此文]] , emacs 只有 dynamic binding ，也就是說所有符號共用一個資料結構來存放 ， 使得內層的函數/迴圈可以影響外層符號，不管這個符號背後是變數或函數。

根據這樣的邏輯，dynamic binding (ie emacs lisp) 在局部變數宣告時， 會先查找環境是否有同名的符號，若然則直接使用它，不在自己的 scope 再定義自己的符號； lexical binding (scheme?) 則無論如何都直接在自己的環境中， 為局部變數定義符號，並且優先查找。

let* 與 let 的不同之處在於，let 的 value 會在與 key 作 binding 前先求值， 因此當 local / global 有同名變數時， 會優先取 global 的值。

更精確的來說， let 會比 let* 多一個迴圈，先對所有的 value 進行 eval ； 後面的部分就都差不多

*** emacs: 
**** let*
[[bookmark:DEFUN%20("let*",%20FletX,%20SletX,%201,%20UNEVALLED,%200,][Bookmark: DEFUN ("let*", FletX, SletX, 1, UNEVALLED, 0,]]

**** let
[[bookmark:DEFUN%20("let",%20Flet,%20Slet,%201,%20UNEVALLED,%200,][Bookmark: DEFUN ("let", Flet, Slet, 1, UNEVALLED, 0,]]

*** mal: 
最外層的環境為 repl_env ，也就是 DEFUN / DEFVAR / DEFCONST 的作用域


*** 小結： DEFVAR => init_XXXX
共 738 個， 其初始化常發生在 init_XXXX 函數中，必需忠實呈現在 js 端
** load-path 的初始化
*** emacs
[[bookmark:init_lread%20(void)][Bookmark: init_lread (void)]]

Vpurify_flag 在 loadup.el 執行期間，其值為真； EMACSLOADPATH 則通常未指定，暫時忽略它

[[bookmark:load_path_default%20(void)][Bookmark: load_path_default (void)]]

[[bookmark:EMACSLOADPATH=$(CURDIR)/../lisp][Bookmark: EMACSLOADPATH=$(CURDIR)/../lisp]]

因此目前暫時將此變數初始化為 ../lisp
*** mal


** or
這部分 mal 有實作，而且是以 self-hosting 的方式，省下寫 js 的工夫
*** mal implementation
[[bookmark:case%20"or":][Bookmark: case "or":]]


*** emacs implementation
 [[bookmark:DEFUN%20("or",%20For,%20Sor,%200,%20UNEVALLED,%200,][Bookmark: DEFUN ("or", For, Sor, 0, UNEVALLED, 0,]]

 [[bookmark:defsubr%20(&Sor);][Bookmark: defsubr (&Sor);]]
** def! / set / setq
** if
*** mal implementation
[[bookmark:case%20"if":][Bookmark: case "if":]]
*** emacs implementation
[[bookmark:DEFUN%20("if",%20Fif,%20Sif,%202,%20UNEVALLED,%200,][Bookmark: DEFUN ("if", Fif, Sif, 2, UNEVALLED, 0,]]

[[bookmark:defsubr%20(&Sif);][Bookmark: defsubr (&Sif);]]

** macroexpand
macroexpand 是一個特殊的算子

mal 實作如下：

[[bookmark:mal/macroexpand][mal/macroexpand]]

#+BEGIN_SRC C
    case 'macroexpand':
        return macroexpand(a1, env);
#+END_SRC 

[[bookmark:mal/function%20macroexpand][mal/function macroexpand]]

#+BEGIN_SRC C
function macroexpand(ast, env) {
    while (is_macro_call(ast, env)) {
        var mac = env.get(ast[0]);
        ast = mac.apply(mac, ast.slice(1));
    }
    return ast;
}
#+END_SRC 

emacs 的實作如下：

[[bookmark:eval/macroexpand][Bookmark: eval/macroexpand]]

#+BEGIN_SRC C
DEFUN ("macroexpand", Fmacroexpand, Smacroexpand, 1, 2, 0,
       doc: /* Return result of expanding macros at top level of FORM.
If FORM is not a macro call, it is returned unchanged.
Otherwise, the macro is expanded and the expansion is considered
in place of FORM.  When a non-macro-call results, it is returned.

The second optional arg ENVIRONMENT specifies an environment of macro
definitions to shadow the loaded ones for use in file byte-compilation.  */)
  (Lisp_Object form, Lisp_Object environment)
{
  /* With cleanups from Hallvard Furuseth.  */
  register Lisp_Object expander, sym, def, tem;

  while (1)
    {
      /* Come back here each time we expand a macro call,
	 in case it expands into another macro call.  */
      if (!CONSP (form))
	break;
      /* Set SYM, give DEF and TEM right values in case SYM is not a symbol. */
      def = sym = XCAR (form);
      tem = Qnil;
      /* Trace symbols aliases to other symbols
	 until we get a symbol that is not an alias.  */
      while (SYMBOLP (def))
	{
	  QUIT;
	  sym = def;
	  tem = Fassq (sym, environment);
	  if (NILP (tem))
	    {
	      def = XSYMBOL (sym)->function;
	      if (!NILP (def))
		continue;
	    }
	  break;
	}
      /* Right now TEM is the result from SYM in ENVIRONMENT,
	 and if TEM is nil then DEF is SYM's function definition.  */
      if (NILP (tem))
	{
	  /* SYM is not mentioned in ENVIRONMENT.
	     Look at its function definition.  */
	  struct gcpro gcpro1;
	  GCPRO1 (form);
	  def = Fautoload_do_load (def, sym, Qmacro);
	  UNGCPRO;
	  if (!CONSP (def))
	    /* Not defined or definition not suitable.  */
	    break;
	  if (!EQ (XCAR (def), Qmacro))
	    break;
	  else expander = XCDR (def);
	}
      else
	{
	  expander = XCDR (tem);
	  if (NILP (expander))
	    break;
	}
      {
	Lisp_Object newform = apply1 (expander, XCDR (form));
	if (EQ (form, newform))
	  break;
	else
	  form = newform;
      }
    }
  return form;
}
#+END_SRC

** try*/catch*
catch 是一個特殊的算子， mal 中使用另一個名字： try*/catch*

mal 實作如下：

[[bookmark:try%20in%20mal][Bookmark: try in mal]]

#+BEGIN_SRC C
    case "try*":
        try {
            return EVAL(a1, env);
        } catch (exc) {
            if (a2 && a2[0].value === "catch*") {
                if (exc instanceof Error) { exc = exc.message; }
                return EVAL(a2[2], new Env(env, [a2[1]], [exc]));
            } else {
                throw exc;
            }
        }
#+END_SRC

emacs 的實作如下：

[[bookmark:eval.c/catch][Bookmark: eval.c/catch]]

#+BEGIN_SRC C
DEFUN ("catch", Fcatch, Scatch, 1, UNEVALLED, 0,
       doc: /* Eval BODY allowing nonlocal exits using `throw'.
TAG is evalled to get the tag to use; it must not be nil.

Then the BODY is executed.
Within BODY, a call to `throw' with the same TAG exits BODY and this `catch'.
If no throw happens, `catch' returns the value of the last BODY form.
If a throw happens, it specifies the value to return from `catch'.
usage: (catch TAG BODY...)  */)
  (Lisp_Object args)
{
  register Lisp_Object tag;
  struct gcpro gcpro1;

  GCPRO1 (args);
  tag = eval_sub (XCAR (args));
  UNGCPRO;
  return internal_catch (tag, Fprogn, XCDR (args));
}
#+END_SRC

* $(RUN_TEMACS) --batch --load loadup bootstrap

** set-buffer
[[bookmark:DEFUN%20("set-buffer",%20Fset_buffer,%20Sset_buffer,%201,%201,%200,][Bookmark: DEFUN ("set-buffer", Fset_buffer, Sset_buffer, 1, 1, 0,]]

** load
[[bookmark:DEFUN%20("load",%20Fload,%20Sload,%201,%205,%200,][Bookmark: DEFUN ("load", Fload, Sload, 1, 5, 0,]]

*** Execute a file of Lisp code named FILE.

*** `load-history'
Loading a file records its definitions, and its `provide' and
`require' calls, in an element of `load-history' whose
car is the file name loaded.  See `load-history'.

*** `load-in-progress' / `load-file-name'
While the file is in the process of being loaded, the variable
`load-in-progress' is non-nil and the variable `load-file-name'
is bound to the file's name.

Check if we're stuck in a recursive load cycle.

    Vloads_in_progress = Fcons (found, Vloads_in_progress);

  /* Get the name for load-history.  */
  hist_file_name = (! NILP (Vpurify_flag)
                    ? concat2 (Ffile_name_directory (file),
                               Ffile_name_nondirectory (found))
                    : found) ;

  version = -1;

*** return
Return t if the file exists and loads successfully.
* 推估應預載模組
(load "emacs-lisp/byte-run")
(load "emacs-lisp/backquote")
(load "emacs-lisp/map-ynp")
(load "emacs-lisp/macroexp")
    (load "emacs-lisp/pcase"))
  (load "emacs-lisp/macroexp"))
(load "emacs-lisp/nadvice")
(load "emacs-lisp/syntax")
(load "emacs-lisp/timer")
(load "emacs-lisp/lisp")
(load "emacs-lisp/lisp-mode")
(load "emacs-lisp/tabulated-list")
      (load "emacs-lisp/regexp-opt")
(load "emacs-lisp/float-sup")