Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions
Privacy Policy




Next: , Up: Building

32.1 Running Compilations under Emacs

Emacs can run compilers for noninteractive languages such as C and Fortran as inferior processes, feeding the error log into an Emacs buffer. It can also parse the error messages and show you the source lines where compilation errors occurred.

M-x compile
Run a compiler asynchronously under Emacs, with error messages going to the ‘*compilation*’ buffer.
M-x recompile
Invoke a compiler with the same command as in the last invocation of M-x compile.
M-x kill-compilation
Kill the running compilation subprocess.

To run make or another compilation command, do M-x compile. This command reads a shell command line using the minibuffer, and then executes the command in an inferior shell, putting output in the buffer named ‘*compilation*’. The current buffer's default directory is used as the working directory for the execution of the command; normally, therefore, the compilation happens in this directory.

The default for the compilation command is normally ‘make -k’, which is correct most of the time for nontrivial programs. (See Make.) If you have done M-x compile before, the default each time is the command you used the previous time. compile stores this command in the variable compile-command, so setting that variable specifies the default for the next use of M-x compile. If a file specifies a file local value for compile-command, that provides the default when you type M-x compile in that file's buffer. See File Variables.

Starting a compilation displays the buffer ‘*compilation*’ in another window but does not select it. The buffer's mode line tells you whether compilation is finished, with the word ‘run’, ‘signal’ or ‘exit’ inside the parentheses. You do not have to keep this buffer visible; compilation continues in any case. While a compilation is going on, the string ‘Compiling’ appears in the mode lines of all windows. When this string disappears, the compilation is finished.

If you want to watch the compilation transcript as it appears, switch to the ‘*compilation*’ buffer and move point to the end of the buffer. When point is at the end, new compilation output is inserted above point, which remains at the end. If point is not at the end of the buffer, it remains fixed while more compilation output is added at the end of the buffer.

If you set the variable compilation-scroll-output to a non-nil value, then the compilation buffer always scrolls to follow output as it comes in.

When the compiler process terminates, for whatever reason, the mode line of the ‘*compilation*’ buffer changes to say ‘exit’ (followed by the exit code, ‘[0]’ for a normal exit), or ‘signal’ (if a signal terminated the process), instead of ‘run’. Starting a new compilation also kills any running compilation, as only one can exist at any time. However, M-x compile asks for confirmation before actually killing a compilation that is running. You can also kill the compilation process with M-x kill-compilation.

To rerun the last compilation with the same command, type M-x recompile. This automatically reuses the compilation command from the last invocation of M-x compile. It also reuses the ‘*compilation*’ buffer and starts the compilation in its default directory, which is the directory in which the previous compilation was started.

Emacs does not expect a compiler process to launch asynchronous subprocesses; if it does, and they keep running after the main compiler process has terminated, Emacs may kill them or their output may not arrive in Emacs. To avoid this problem, make the main process wait for its subprocesses to finish. In a shell script, you can do this using ‘$!’ and ‘wait’, like this:

     (sleep 10; echo 2nd)& pid=$!  # Record pid of subprocess
     echo first message
     wait $pid                     # Wait for subprocess

If the background process does not output to the compilation buffer, so you only need to prevent it from being killed when the main compilation process terminates, this is sufficient:

     nohup command; sleep 1

You can control the environment passed to the compilation command with the variable compilation-environment. Its value is a list of environment variable settings; each element should be a string of the form "envvarname=value". These environment variable settings override the usual ones.

  Published under the terms of the GNU General Public License Design by Interspire