Come posso annidare una tabella di sintassi in un'altra?

Ho scritto una modalità semplice per la gestione di JSON. Utilizza i macchinari derivati ​​per riutilizzare la maggior parte del codice della modalità json. Comunque un'aggiunta è che puoi inserire elisp nel testo JSON che viene valutato al momento dell'invio di JSON. Ad esempio un estratto di JSON è simile al seguente:

{
    "parameters": {
        "IRC_USER": "stsquad",
        "PUB_KEY": `(format "\"%s\"" (s-trim (shell-command-to-string "cat ~/.ssh/id_rsa.pub")))`
    }
}

Attualmente l'evidenziazione della sintassi di questo testo è interrotta quando l'illuminatore della sintassi JSON viene lanciato dall'elisp. Vorrei impostare una tabella di sintassi nidificata in modo che elisp sia correttamente riconosciuto come elisp all'interno dei caratteri di escape (ho scelto `in questo caso). Capisco che puoi unire i char-table (da cui sono basate le tabelle di sintassi) con qualcosa del tipo:

(defvar lava-mode-syntax-table
  (let ((json-table (copy-syntax-table json-mode-syntax-table))
        (elisp-table (copy-syntax-table lisp-mode-syntax-table)))
    (set-char-table-parent elisp-table json-table)
    (modify-syntax-entry ?` "(`" json-table)
    (modify-syntax-entry ?` ")`" json-table)
    json-table)
  "LAVA Mode syntax table.
This is a combination of json-mode-syntax-table with an escape into
  lisp-mode-syntax table for the embedded elisp.")

Ma non capisco come posso modificare la tabella di sintassi per iniziare a usare la tabella di sintassi child (elisp) mentre si è tra i caratteri di escape?

Non vuoi nidificare una tabella di sintassi (che è una struttura vettoriale) all'interno di un'altra, vuoi impostare un buffer in cui, a seconda della posizione, verrebbe utilizzata una tabella di sintassi anziché l'altra.

L'altra risposta descrive come fare ciò usando la syntax-tableproprietà text. Ecco come farlo usando uno dei pacchetti "multiple major mode", mmm-mode . Userà tutto nella modalità primaria al livello più alto del buffer e la tabella di sintassi della sottomodalità, le regole di blocco dei caratteri, la mappa dei tasti, ecc. Nelle "sottoregioni".

(require 'mmm-auto)
(setq mmm-global-mode 'auto)

(mmm-add-classes
 '((eljson :submode emacs-lisp-mode
           :front ": *\\(`\\)" :back "`"
           :front-match 1
           :face mmm-code-submode-face)))

(mmm-add-mode-ext-class 'json-mode "\\.el\\.json\\'" 'eljson)

Ciò presuppone che i file in modalità mista siano denominati *.el.json. Regola come appropriato.

Ora installa mmm-mode, valuta quanto sopra e (solo allora) apri uno dei file in questione.

Ok, chiariamo alcune nozioni di base.

È possibile annidare le tabelle di sintassi

Le tabelle di sintassi non devono essere globali per l'intero buffer. Puoi applicarli come proprietà di testo a regioni specifiche. Ciò significa che puoi effettivamente applicare la elisptabella di sintassi solo alle regioni circondate da backtick.

Come si fa a farlo?

Ecco un modo per farlo. Questo metodo lo fa immediatamente prima dell'esecuzione del blocco dei caratteri attraverso il buffer, quindi dovrebbe prevenire specificamente i problemi di blocco dei caratteri.

(defun endless/set-syntax-then-fontify (beg end loudly)
  "Apply elisp syntax table to relevant regions before calling font-lock."
  (save-match-data
    (save-excursion
      (save-restriction
        (widen)
        (narrow-to-region beg end)
        (while (search-forward "`" nil 'noerror)
          ;; Using `end' here excludes the `, I don't know which syntax you
          ;; want to apply to that.
          (let ((left (match-end 0)))
            (when (search-forward "`" nil 'noerror)
              (add-text-properties
               left (match-beginning 0)
               (list 'syntax-table emacs-lisp-mode-syntax-table))))))))
  (font-lock-default-fontify-region beg end loudly))

Nella definizione della modalità principale, dovrai aggiungere:

(set (make-local-variable 'font-lock-fontify-region-function)
     #'endless/set-syntax-then-fontify)

Le tabelle di sintassi non sono le stesse dell'evidenziazione della sintassi

L'evidenziatore di sintassi (il sistema di blocco dei caratteri) utilizza le Tabelle di sintassi come parte delle sue informazioni, quindi la soluzione sopra dovrebbe impedire all'evidenziatore di impazzire.

Tuttavia, questa è solo una parte dei dati, se vuoi anche che il testo nei backtick sia colorato esattamente come vedresti in un buffer elisp, dovrai estendere la funzione sopra per farlo in modo specifico.

(defun endless/set-syntax-then-fontify (beg end loudly)
  "Apply elisp syntax table to relevant regions before calling font-lock."
  (save-match-data
    (save-excursion
      (save-restriction
        (widen)
        (narrow-to-region beg end)
        (while (search-forward "`" nil 'noerror)
          ;; Using `end' here excludes the `, I don't know which syntax you
          ;; want to apply to that.
          (let ((left (match-end 0)))
            (when (search-forward "`" nil 'noerror)
              (add-text-properties
               left (match-beginning 0)
               (list 'syntax-table emacs-lisp-mode-syntax-table))))))))
  (font-lock-default-fontify-region beg end loudly)
  ;; Do some specific elisp fontifying here
  (save-match-data
    (save-excursion
      (save-restriction
        (widen)
        (narrow-to-region beg end)
        (while (search-forward "`" nil 'noerror)
          (let ((left (match-end 0)))
            (when (search-forward "`" nil 'noerror)
              ;; Call some function to fontify elisp between `left' and (match-beginning 0)
              )))))))