C-u C-M-x evaluates a defun form with edebug instrumented. Can I do that programmatically? I want to do that because I want to write an elisp file of the following form:
;;; define a function with edebug instrumented.
...
;;; do something that invokes the function with particular arguments.
...
then I can run emacs -q --load on that elisp file, step through code, get an idea on further investigation on the bug, edit the elisp file in my original emacs session, run emacs -q --load on it again, and repeat.
In ~/test.el:
(defun square (x)
(* x x))
In ~/testtest.el:
(with-current-buffer (find-file-noselect "~/test.el")
(re-search-forward "square")
(edebug-defun))
(square 5)
In bash:
emacs -q -l ~/testtest.el
Related
In my environment, I have bash autocomplete set up to do lots of amazing things.
However, when I'm editing a shell script in emacs, all of that autocomplete magic goes away.
Is there any way to get emacs to do bash command line autocompletion when I'm editing shell scripts?
I would accept an answer that requires me to use a different editor, if that editor were available on Linux systems. I would also accept an answer that tells me that I need to use a different shell's autocomplete.
bash-completion.el provides an interface to normal bash completion, which can also be extended to work in normal sh-modes with an addition to your completion-at-point-functions. Here is how that could work, just using the command sh-beginning-of-command from sh-script to determine the current completion candidate (this could be extended to handle more complicated shell commands if necessary).
(require 'sh-script) ;sh-beginning-of-command
(require 'bash-completion)
(defun my-sh-completion-at-point ()
(let ((end (point))
(beg (save-excursion (sh-beginning-of-command))))
(when (and beg (> end beg))
(bash-completion-dynamic-complete-nocomint beg end t))))
(defun my-sh-hook ()
(add-hook 'completion-at-point-functions #'my-sh-completion-at-point nil t))
(add-hook 'sh-mode-hook #'my-sh-hook)
I read in the documentation and rosetta code that (read) is used to get input from the console. So I wrote this code to check this:
(display (+ (read) 1))
But mit-scheme never asks for user input and the program just terminates. Why is this the case?
In the REPL, (display (+ (read) 1)) works as expected.
When (display (+ (read) 1)) is placed in a source file, and the file is run as a script using mit-scheme --quiet < program.scm (reference), mit-scheme never asks for user input and the program just terminates. Why?
To see the reason, place this in the source file instead:
(define n (read))
2
(display (+ n 1))
You get 3, as expected.
This is all caused by the shell input redirection (i.e. <). read gets its input from the current input port by default. With shell input redirection, the current input port is the source file. Hence, (read) does not prompt for user input because stdin is the source file.
To the best of my knowledge, there is currently no easy way to correctly run an MIT Scheme script directly from the command line (surprise! surprise! MIT Scheme is antiquated). Relevant mailing list discussion: [MIT-Scheme-devel] How to run a script and exit?.
I want to send a command to a comint shell-mode without it printing an additional prompt. I'm trying to use the comint-redirect-* API, but I am still getting an additional prompt. What would be an easy way to either avoid the prompt printing altogether, or to track back and delete it?
My redirect,
(defun my-comint-redirect-silently (proc string)
(let (comint-redirect-perform-sanity-check)
(with-temp-buffer
;; possible to have shell not print prompt?
(comint-redirect-send-command-to-process
string (current-buffer) proc nil 'no-display)))
(with-current-buffer (process-buffer proc)
;; necessary to track back and delete here?
(comint-redirect-cleanup)))
Example of a call in a shell-hook,
(add-hook 'shell-mode-hook
(lambda ()
(my-comint-redirect-silently
(get-buffer-process (current-buffer)) "TERM=xterm-256color")))
But, the comint shell then prints the following (notice the double prompt)
me#me-M51AC: ~
$ me#me-M51AC: ~
$
Not directly relevant, but to show it is printing twice, the prompt here is set as
$ echo $PS1
${debian_chroot:+($debian_chroot)}\[\e[32m\]\u#\h: \[\e[33m\]\w\[\e[0m\]\n\$
I took at look at how comint-redirect-results-list-from-process worked and bodged this.
(defun comint-run-thing-process (process command)
"Send COMMAND to PROCESS."
(let ((output-buffer " *Comint Redirect Work Buffer*"))
(with-current-buffer (get-buffer-create output-buffer)
(erase-buffer)
(comint-redirect-send-command-to-process command
output-buffer process nil t)
;; Wait for the process to complete
(set-buffer (process-buffer process))
(while (and (null comint-redirect-completed)
(accept-process-output process)))
;; Collect the output
(set-buffer output-buffer)
(goto-char (point-min))
;; Skip past the command, if it was echoed
(and (looking-at command)
(forward-line))
;; Grab the rest of the buffer
(buffer-substring-no-properties (point) (- (point-max) 1)))))
Hope it helps
I am newbie to Emacs.
I want to define a function in elisp to run a command in interactive command line mode (Asynchronously if possible).
my current code is:
(defun ma () ;run maxima batch on the current file
(interactive)
(let*
((fn (buffer-file-name)) (cmd (concat "maxima -b " fn)))
(message "cmd:%s" cmd)
(shell-command cmd)
)
)
this works fine when I do not have break points in the maxima code. When I have break points "break()", I have to interact with the program. The current shell-command function does not work.
I also like the mechanism of "shell-command" function that the screen will automatically split into two and show the programming running info in a second window. If possible, I still want this feature in the code that you can help me with.
Any help would be appreciated.
I want to define a function in elisp to run a command in interactive
command line mode (Asynchronously if possible).
Maybe async-shell-command is what you are looking for do C-h f async-shell-command RET for help on the function.
Use the built in compile function in commint mode.
(defun ma (&optional filename)
(interactive)
(compile (format "maxima -b %s" (or filename (buffer-file-name))) t))
This will open up a new window and will show you the output of the program running. Commint mode means that the compilation process is interactive, you will be able to send input to the program from the compilation buffer.
I am trying to run a scheme program using MIT-scheme (MIT/GNU Scheme running under GNU/Linux, Release 7.7.90.+ || Microcode 15.1 || Runtime 15.7) and I would like to access the command-line arguments.
I have looked in the documentation but I haven't found anything specific.
I have tried command-line, but I get an error message:
;Unbound variable: command-line
Do I have to load some library in order to use command-line, or is there some other function for this?
I have managed to find the following solution.
I have created a file init.scm with the following definitions:
(define command-line-args '())
(define parse-argument-list
(lambda (arg-list)
(set! command-line-args
(if (null? arg-list)
(list)
(cdr arg-list)))))
(set-command-line-parser! "args" parse-argument-list)
In this way, when the command line option --args is found, the function
parse-argument-list is invoked.
I have loaded this file into the mit-scheme interpreter and saved a world image
(init.com) using the procedure disk.save.
I have then written a shell script (bash) that invokes my main Scheme script as follows:
mit-scheme --band "init.com" --interactive --batch-mode --args $* < myscript.scm
Finally, in my main script I can access the command line arguments through the variable
command-line-args
I am not sure whether this is the standard / correct way to do this but at least it works.