Esta pregunta está inspirada en https://stackoverflow.com/q/605785/ . Por M-x describe-function <TAB>puedo obtener una lista de todas las funciones interactivas o no atractivas disponibles en el estado actual de emacs. Si se activa un modo específico (por ejemplo, modo látex) obtenemos una lista más larga, ya que también se enumeran las funciones disponibles en el modo látex.

Mi pregunta es cómo obtener una lista de todas las funciones disponibles exclusivamente en un modo específico (por ejemplo, modo látex). En otras palabras, excluyendo todas las demás funciones no proporcionadas por ese modo. Al igual que en el enlace anterior, también sería útil proporcionar una breve descripción de las funciones.

¿Qué significa que un modo proporcione una función? Usted dice " una lista de todas las funciones disponibles exclusivamente en un modo específico " y " excluyendo todas las demás funciones no proporcionadas por ese modo ".

Parece que estás confundiendo un modo con la biblioteca que lo define . Una biblioteca proporciona / define funciones. Un modo generalmente no lo hace.

Si desea obtener una lista de todas las funciones definidas en una biblioteca determinada , consulte la respuesta de @ wvxvw, para comenzar. También puede intentar hacer coincidir el prefijo de la biblioteca con los nombres de las funciones, que a menudo es pertinente, pero de ninguna manera es definitivo.

Sin embargo, si desea obtener una lista de todas las funciones que podrían ser relevantes para un modo dado , por ejemplo, funciones que solo se pueden usar, o que son más útiles, cuando ese modo está activado, entonces me temo Deberá examinar la biblioteca donde se define el modo. E incluso podría necesitar examinar algunas otras bibliotecas.

Una biblioteca dada generalmente define más que solo algunas cosas que son pertinentes a un modo dado. Y un modo dado puede hacer uso de cosas que están definidas en diferentes bibliotecas, y en algunos casos cosas que tienen sentido solo para ese modo dado o un conjunto de modos que lo incluye.

En resumen, como se plantea actualmente, su pregunta no es muy clara. Puede ayudarse a sí mismo a obtener mejores respuestas al aclararlo.

Quizás, este código tendrá algún efecto educativo:

(defun remove-all-extensions (file-name)
  (let ((go-on t) next)
    (while go-on
      (setq next (file-name-sans-extension file-name))
      (setq go-on (not (string= next file-name))
            file-name next))
    next))

(defun function-symbols-of (library)
  (let ((origin (remove-all-extensions
                 (find-library-name
                  (if (stringp library) library
                    (symbol-name library)))))
        (result))
    (mapatoms (lambda (sym)
                (when (and (symbol-function sym)
                           (symbol-file sym)
                           (string= (remove-all-extensions (symbol-file sym))
                                    origin))
                  (push sym result))))
    result))

El problema

Debido a la naturaleza no determinista del análisis y la carga del código, se deben abordar varios problemas:

1. ¿Cuándo se define la función en un archivo? Las funciones se pueden definir condicionalmente, y predecir si una condición favorecerá la definición de la función o no es equivalente a resolver el problema de detención. Para ilustrar esto, suponga que este código:

   (if (> (random 100) 50)
      (defun foo ())
      (defun bar ()))
   

2. En general, no es posible saber si un formulario lisp definió una función antes (con éxito) de evaluar el formulario. Esto es, de nuevo, equivalente al problema de detención, por lo tanto, no se puede resolver en general.
3. Hay algunos casos especiales comunes, como el alias y el asesoramiento, que (a) crean duplicados, (b) pueden confundirlo con el archivo fuente que declaró la función.
4. Se declara una gran fracción de funciones en el código C (no necesariamente accesible), que en realidad no se divide en bibliotecas en el mismo sentido que el código Emacs Lisp.

Dicho todo esto, probablemente desee buscar find-func.elinspiración, para tener una idea general del diseño y los problemas relacionados con la ubicación del código fuente para las funciones de Emacs Lisp.

Acabo de agregar esta funcionalidad a lispy . El nuevo comando lispy-goto-elisp-commands, está obligado a oge.

El genérico g( lispy-goto) proporciona una lista de todas las etiquetas, resaltando los comandos con una cara diferente, mientras que lispy-goto-elisp-commandssolo proporciona las etiquetas de comando.

Listado de código

(defun lispy-goto-elisp-commands (&optional arg)
  "Jump to Elisp commands within current file.
When ARG is non-nil, force a reparse."
  (interactive "P")
  (deactivate-mark)
  (let ((lispy-force-reparse arg))
    (lispy--fetch-tags (list (buffer-file-name)))
    (let ((struct (gethash (buffer-file-name) lispy-db)))
      (lispy--select-candidate
       (mapcar #'lispy--format-tag-line
               (delq nil
                     (cl-mapcar
                      (lambda (tag pretty-tag)
                        (when (semantic-tag-get-attribute tag :user-visible-flag)
                          pretty-tag))
                      (lispy-dbfile-plain-tags struct)
                      (lispy-dbfile-tags struct))))
       #'lispy--action-jump))))

Esto es solo para mostrar que la semántica de CEDET se utiliza para obtener la lista de etiquetas; (semantic-tag-get-attribute tag :user-visible-flag)se usa para determinar si la etiqueta es un comando o no.

Cómo utilizar

1. Navegue hasta el archivo que contiene el código. Esto se puede hacer con f1 f. Me gusta usar el consejo-describir-función en su lugar, ya que presionar C-.allí omite tener que pasar por el *Help*búfer.

2. Haga que el punto sea especial (muévalo antes de abrir el par, o active la región) y presione oge. También es posible simplemente usar M-x lispy-goto-elisp-commands.

El paquete smex tiene un código para enumerar todos los comandos de un paquete. Puede adaptar este código para obtener todas las funciones.