I try to read source code of quickrun, But failed, I don't know how to add support for Julia.
So I add an issue here.

BTW, can you add an example in README, let user can reference to add new support?

For me, I keep getting the ^M new line character for output. Here is an example when running an emacs-lisp file:

I have this is my init.el to set the coding system, but it doesn't seem to work.

(setq default-buffer-file-coding-system 'utf-8-auto)

I'd appreciate the help.

@tarsius Is there anyone already maintaining this package? This package is great! Let me know if I can maintain this package! :)

Thanks!

Because I want to run a node.js server, I set quickrun-timeout-seconds to nil, then nothing can be printed.

I then test with a php file, here is the result:
Process quickrun-process-php finished

Is it a intended feature, or how should I fix it?

Could we have a button in to tool bar for the quickrun command? I think it would be nice for people who are new to emacs.
Something like this:
(tool-bar-add-item "run" 'quickrun 'quickrun :help "Compile and execute the buffer")

Here is a nice xpm picture file that would look good as the button (I totaly didn't steal it from Netbeans) (I know it says .png but just rename it to .xpm)

Is it possible to add an easy way to run with either python or python3?

When I run M-x quickrun repeatedly with the following setup, everything works. However, if I press Cmd-r repeatedly, the focus part only works the first time. On the second run, my cursor is placed in the quickrun buffer. Is there something else I need to do?

(require 'quickrun)
(global-set-key (kbd "s-r") 'quickrun)
(setq quickrun-focus-p nil)

Thanks for the great package! I love it.
Can it support Ivy? Since I find it support helm well.

quickrun rustc with C-u C-u (compile only) will give below error:

-*- mode: compilation; default-directory: "~/Rust/101/" -*-
Comint started at Thu Jan 26 15:30:53

rustc --no-trans --warn-unused-imports  -o /Users/pro/Rust/101/1.out 1.rs
error: Unrecognized option: 'no-trans'.


Comint exited abnormally with code 101 at Thu Jan 26 15:30:53

Rust 1.14

ansi color code is not support?

I run quickrun, c++ compile error log on quickrun buffer is

�[1mqr_3031oQQ.cpp:5:1: �[0m�[0;1;31merror: �[0m�[1mC++ requires a type specifier for all declarations�[0m
a;
�[0;1;32m^
�[0m1 error generated.

I expect error log, as follows

Welcome to the Emacs shell

$ 
$ clang++ -O3 -std=c++1z xorshift.cpp 
xorshift.cpp:5:1: error: C++ requires a type specifier for all declarations
a;
^

env

I use quickrun version is

;; Package-Version: 20151203.2152
;; Version: 2.2.6

emacs and gcc version is

$ emacs --version
GNU Emacs 24.5.1
...
$ gcc --version
gcc (Debian 5.3.1-5) 5.3.1 20160101
...

To reproduce:

• Run a program using Eshell.
• Press any key and quickrun exits Eshell immediately, prevent users from copying the output.

Windows環境で、テンポラリファイルが削除されずに残ることがある。
理由は

    gcc -o output foo.c

としたときに、outputではなく、output.exeが生成されてしまうため。

If I firstly executed quickrun-shell when the file of current buffer is in directory A,
then I change current buffer to another file in directory B, and execute quickrun-shell again,
it will fail to find the file to compile, because it still try to find it in the directory A.

Moreover, I don't think the minibuffer is a good place to show the message "Press 'r' to run again, any other key to finish", because it will easily go away if I were doing something else in the mean time. Is it possible to show it in the program running buffer? And would the terminal-emulator function be the better choice than eshell for running the program?

Thanks for making emacs-quickrun, it's great.
I use it to eval current ruby buffer. only problem is that it scrolls the output out of sight. so if buffer just consists of: "puts 'hello'" and I quickrun it, I need to scroll up in the quickrun buffer to see the output because the buffer scrolls it out of sight.

2 other questions:
Can I have it not move my cursor into the quickrun buffer?
Can quickrun buffer be vertical to the right of my edit buffer?

Let it opened by system default associated external program.
In Linux, it is runned by a command (I forget what it is... :( )

I'm very new to Emacs, it would be great that I can archive this within quickrun.

I tried emacs -Q (with master branch emacs)
and I checked quickrun.el and quickrun.elc (updated today)

In following file named array.nim, the compile process should fail
because of using same file name and type, but M-x quickrun success to compile.
(Nim recognizes file name as module name, so. about module)

array.nim

var a: array[0..2, int] = [1, 2, 3]
for ary in a:
  echo ary

from M-x quickrun:
-> 1, 2, 3

from shell:

$ nim compile --run --verbosity:0 array.nim # <- actually I tried absolute path
array.nim(1, 8) Error: ambiguous identifier: 'array' -- use a qualifier

nim version:

$ nim --version
Nim Compiler Version 0.13.1 (2016-02-01) [Linux: amd64]
Copyright (c) 2006-2016 by Andreas Rumpf

git hash: ac1e7a245093bb28a1a366f1e169ab50e6660c94
active boot switches: -d:release

When I run quickrun with eshell, and abort the program before it finishes with C-c C-c, quickrun always scrolls my code buffer to the bottom, which is annoying.

To reproduce:

• Set quickrun to use Eshell.
• Run a program with some input i.e. scanf
• When you are asked for input, C-c C-c to abort the program and press q to quit Eshell.
• Point is at the bottom in code buffer.

using quickrun-replace-region throws the error : Wrong type argument: window-live-p, nil (region get replaced as expected). For example on this python code : print("hello")
I have solve the issue with :

*** a/quickrun.el
--- b/quickrun.el
***************
*** 868,875 ****
                       (message "Failed: Exit Status=%d" exit-status))
                   (quickrun/apply-outputter outputter-func)
                   (run-hooks 'quickrun-after-run-hook))
!                (cond ((> scroll-conservatively 0) (quickrun/recenter nil))
!                      ((/= scroll-step 0) (quickrun/recenter -1)))
                 (quickrun/remove-temp-files)))))))

  ;;
--- 868,876 ----
                       (message "Failed: Exit Status=%d" exit-status))
                   (quickrun/apply-outputter outputter-func)
                   (run-hooks 'quickrun-after-run-hook))
!                (unless (string= outputter-func 'replace)
!                  (cond ((> scroll-conservatively 0) (quickrun/recenter nil))
!                        ((/= scroll-step 0) (quickrun/recenter -1))))
                 (quickrun/remove-temp-files)))))))

  ;;

Regards
lompik

Hi and thx for this great package!

im a neewb and having trouble configuring how why when i use quicklaunch emacs opens a ugly buffer beside the current one. is there a way to disable this?
thx so much!

Z

When working on a remote buffer with Tramp, quickrun cannot see it and try to execute the file locally and fails.

Quickrun is GREAT, however, I failed to find a way to input something to the running program except for using the quickrun-with-input-file command. It is very inconvenient when I want to input something freely.

It may be better to execute the program with the built-in function -- term, which enables us to interact with the running program.

Quickrun-shell is the way to enable stdin when running a file, but the way it does this is via eshell, which doesn't load the standard environment.

For example, this means if you use something like pyenv to manage python installations, quickrun and quickrun-shell will run two different versions of python.

Afaik eshell explicitly does not try to load bash profiles or anything like that, so there's no real way to make this work with eshell.

But what you can do, however, is instead of using eshell, use compilation-start and pass t to put it in interactive mode.

I'm not sure if you can get the "press R to restart" behavior with comint mode, but I'd much rather have stdin and consistent environments than the ability to rerun with a single key. That's what M-x repeat-command is for 😛

It would be much nicer if the error output is displayed in a Compilation buffer, you we can navigate errors back and forth easily.

I'm trying to open a new Emacs.app to do some tests and print logs in there:

;; Local Variables:
;; quickrun-option-cmd-alist: ((:command . "/bin/bash")
;;                             (:exec    . ("open -a /Applications/Emacs-26.3.app --args -Q -l %d/%s"))
;;                             (:tempfile . nil))
;; End:

How should I do to inhibit the *quickrun* window in original Emacs?

Hi,

I think this is a useful feature. Let me explain the use case: in competitive programming, you often need to get file input through standard stream. Something like this:

./program < test_case1.txt

It would be nice if I can reuse quickrun-with-arg for multiple files. This is my hack to achieve that:

  (defalias 'qrr 'quick-run-multiples-redirect)
  (defun quick-run-multiples-redirect (buf-name &rest args-list)
    (let* ((cur-buf (if buf-name (get-buffer buf-name) (current-buffer)))
           (cur-window (get-buffer-window cur-buf))
           (result))
      (dolist (arg (hif-flatten args-list))
        (with-current-buffer cur-buf
          (select-window cur-window)
          (delete-other-windows)
          (select-window cur-window)
          (quickrun-with-arg (concat "< " arg))
          (sit-for 1)
          (with-current-buffer quickrun--buffer-name
            (setq result (concat result arg ": "  (buffer-string))))))
      (with-current-buffer (generate-new-buffer quickrun--buffer-name)
        (erase-buffer)
        (insert result)
        (quickrun--mode)
        (switch-to-buffer (current-buffer)))))

So, in eshell, I can put command like this:

qrr file.cpp (edf ".*.txt")

• qrr is the alias of quick-run-multiples-redirect.
• file.cpp is the file for quickrun-with-arg to run on.
• (edf ".*.txt) expands all the .txt files in the current directory. edf is the alias for eshell-directory-files.

Here is an example C++ file:

#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    int n, tmp;

    cin >> n;

    while (cin >> tmp) {
        cout << tmp;
    }

    debug(n, tmp);

    return 0;
}

Here is a sample test case:

5
1 2 3 4 5

Essentially, I will have many of such test cases, and I want to run all of them with a single command. With the qrr command, it is able to do that, but then it opens a *quickrun* buffer for every test case before it finally aggregates results into the final buffer.

Every time I run quickrun, the temp file is left there. Is there any specified reason for keeping these files ?
quickrun.el

In README, you give an example on how to run perldoc on a POD file. Is it just me not being able to see how to run quickrun on a perl file and execute that perldoc statement?

I've set the command and key bindings for running perl interpreter from plenv with and without arguments, but I can not see a way to run perldoc, too.

"\.v\'" already used by vlang issue in vlang repo
So add it into quickrun-file-alist will cause conflicts.
Is there any proper way to solve this?

Distribution: ArchLinux
Emacs: GNU Emacs 27.1
Quickrun version: 2.3.0
Python version: 3.8.5
Emacs function used: M-x quickrun

Hello,
As mentioned in the title, Python scripts are not working unless if I use a more direct path to the Python interpreter (!#/usr/bin/python). Example: the only error outputted in the quickrun buffer looks like this:

Traceback (most recent call last):
  File "meteo.py", line 3, in <module>
    from env_canada import ECData
ModuleNotFoundError: No module named 'env_canada'

I have no clue what might cause this problem, hence why I've opened this issue. Let me know if you need more details.

Hi, guys. Sorry to raise this issue. I've read the readme, but still can't figure out how to change my scheme file run command. Let's say that I want my current scheme file run by the command chez --script, How would I do that?
I'm using use-package and this is my current config file. But it raises an error, now. Please help me. Thanks!

(use-package quickrun
  :config
  (quickrun-add-command "scheme"
    '((:exec . ("%c -std=chez --script %o -o %e %s"
                "%e %a")))
    :default "scheme"
    :override t)
  :ensure t)

Is it possible to show a message indicate that the program has been exit (similar to compile command)? This will be very useful for long running programs/scripts.

Thanks

I want to check translated code.
for example convert javascript to typescript.

#![allow(dead_code)] not support for rust in the head of rust file.

error message:

'[allow' is not recognized as an internal or external command,
operable program or batch file.

On windows.

• helm-quickrun-region
• helm-quickrun-with-arg
• helm-quickrun-shell
• helm-quickrun-compile-only
• helm-quickrun-replace-region

Example use case: When writing an HTML document, you could write a part in markdown (e.g., a list), select it, and transform it to HTML using helm-quickrun-replace-region.

If I run (quickrun), it opens the *quickrun* buffer in a window. Then, if I run (quickrun) again, it moves the buffer out of the original window and into a new window. I want the *quickrun* buffer to stay in one window consistently so I can have my source code files in certain designated windows and *quickrun* in another designated window. (Note that Emacs compile commands open the *Compilation* buffer, and they have the behavior I want, where they will keep the buffer in the same window if it's already visible.) How do I make quickrun behave like this?

I tried using Emacs's dedicated-window functionality, but that doesn't work. If I mark the window with *quickrun* as a designated window and then run (quickrun) again, it closes the window with *quickrun* in it and then puts *quickrun* in a different window.

Help on this issue is much appreciated.

quickrun-shell creates a buffer named eshell-quickrun,then quickrun--mode-map is enabled in every eshell buffer include eshell.
so,"q" is bind to (quickrun--eshell-window-restore) in every eshell buffer(including eshell buffer) instead of just in eshell-quickrun;;

I guess this could be a bug,and can be reproducted with minimal setup;

(require 'quickrun)

Ive bound 'quickrun to a key but everytime I use it the frame/window is resized to the middle of the screen, this can get annoying after I have run it the first time then resize the frame/window and then run it again the frame/window goes back to the middle.... how can I stop that?

Great package by the way... keep up the good work.

Is there a plan to add a feature where one can specify how long is the timeout for a process but on a command basis? For example, quickrun-add-command can take an extra argument :timeout which controls the behavior of the specific command.

If the effort is not that big, I could implemented it myself. Would you be interested in PR?

The source file is as following:

#include <stdio.h>

int main()
{
    printf("Hello\n");
    return 0;
}

But M-x quickrun gives no output, while a new buffer named *quickrun* is created.

Hi, I'm using quickrun in doom emacs. I recently noticed that using quickrun in a file which has a space in its pathname causes an error, taking the part after the space as a second argument. I wonder if it is something that's easy to fix?

I have a toy programming language that I want to just use the source file name instead of copying to temporary file first after invoking quickrun (like the case of Java language).

Could it be possible to provide such customised variable that users can specify for which quickrun will not generate a temporary file?

When you M-x quickrun on foo.cpp.qrinput, it would be convenience to execute the command on corresponding code buffer (foo.cpp) if available instead of *.qrinput buffer itself.

For example, I have an interactive C++ program that requires input. For this reason, I use the quickrun-shell command over the quickrun command. But, the cursor is on *quickrun* by default and I have to switch to *eshell* buffer manually. Also, I have to quit the eshell before quitting the *quickrun* buffer because if I press q to quit *quickrun* buffer first, quitting *eshell* bufferr gives error, so it's better for the cursor on shell buffer by default.

When I run quickrun in a Common Lisp file -- test.lisp -- I get the following error: not found [lisp] language information.

Any advice? I have clisp installed.

I use following popwin config

(add-to-list 'popwin:special-display-config "*quickrun*")

But popwin handle only *quickrun* buffer with compilation state. After that quickrun pop to buffer running application. At that moment popwin mess window control. Now you can't close *quickrun* window with C-g.

Get this behavior at c-mode with single c source file and gcc compiller.

現在は requireするしか quickrunを読み込めないので、
autoloadに対応する。

When I run quickrun, it puts all output to a buffer, and applies colors after it is finished. In my opinion that's a bit ugly, especially when you are watching what is happening in that buffer:

�[32mHint: �[0mhello_triangle�[36m [Processing]
�[0m�[32mHint: �[0mmacros�[36m [Processing]
�[0m�[32mHint: �[0msequtils�[36m [Processing]
�[0m�[32mHint: �[0mx�[36m [Processing]
�[0m�[32mHint: �[0mxlib�[36m [Processing]
�[0m�[32mHint: �[0mxutil�[36m [Processing]
�[0m�[32mHint: �[0mkeysym�[36m [Processing]
�[0m�[32mHint: �[0mdynlib�[36m [Processing]
�[0m�[32mHint: �[0mstrutils�[36m [Processing]
�[0m�[32mHint: �[0mparseutils�[36m [Processing]
�[0m�[32mHint: �[0mmath�[36m [Processing]
�[0m�[32mHint: �[0malgorithm�[36m [Processing]
�[0m�[32mHint: �[0mvec�[36m [Processing]
�[0m�[32mHint: �[0mmat�[36m [Processing]
�[0m�[32mHint: �[0mmat_transform�[36m [Processing]
�[0m�[32mHint: �[0mglobals�[36m [Processing]
�[0m�[32mHint: �[0mquat�[36m [Processing]
�[0m�[32mHint: �[0mtimes�[36m [Processing]
�[0m�[32mHint: �[0munsigned�[36m [Processing]
�[0m�[32mHint: �[0mposix�[36m [Processing]
�[0m�[32mHint: �[0mospaths�[36m [Processing]

When I use quickrun-shell, all color is applied directly, but this one has the disadvantage, that it does change focus to that window, even though I do not want that (I configured quickrun-focus-p). I almost wanted to commit the issue, that quickrun-focus-p does not have an effect on quickrun-shell, but then I realized it was intentional, because that command is interactive programs. Is there a solution for my problem?