$ cp clangshebang.cpp myprogram.cpp
$ chmod +x myprogram.cpp
$ ./myprogram.cpp
hello shellIn Emacs init.el:
(global-set-key (kbd "<f5>") #'my/try-build-run-project)
(global-set-key (kbd "<f7>") #'my/try-build-project)In emacs session, hit f5. It will run myprogram.cpp.
In terminal:
$ ./myprogram.cpp --gen-emacs-dirlocalsIn emacs session, hit f5. It will do the right thing.
If you just want to build, hit f7.
I haven't added projectile-projectile-test-cmd yet because I am lazy.
| #if 0 | |
| if [ "$1" == "--gen-emacs-dirlocals" ]; then | |
| if [ -f ".dir-locals.el" ]; then | |
| echo ".dir-locals.el already exists, you'll have to edit them yourself, sorry" | |
| exit 1 | |
| else | |
| touch .projectile | |
| touch .dir-locals.el | |
| echo "((nil . ((projectile-project-run-cmd . \"$0 --just-run\")" >> .dir-locals.el | |
| echo " (projectile-project-compilation-cmd . \"$0 --just-compile\")" >> .dir-locals.el | |
| echo " )))" >> .dir-locals.el | |
| echo "Generated .dir-locals.el" | |
| ehco 'You may need to run(hack-dir-local-variables-non-file-buffer) inside Emacs' | |
| exit 0 | |
| fi | |
| fi | |
| compiler_command=$CC | |
| if [ "$compiler_command" == "" ]; then | |
| compiler_command="clang++" | |
| fi | |
| outfile=${0%.*} | |
| default_compiler_flags=" \ | |
| -g -std=c++1y -Weverything -Wpedantic -Werror -Wno-c++98-compat \ | |
| -Wno-missing-prototypes -Wno-padded -Wno-double-promotion -Wno-documentation -Wno-documentation-unknown-command \ | |
| -Wno-gnu-anonymous-struct -Wno-nested-anon-types -Wno-c++98-compat-pedantic -Wno-newline-eof -Wno-old-style-cast \ | |
| -Wno-sign-conversion -Wno-comma -Wno-implicit-fallthrough -Wno-reserved-id-macro -Wno-cast-align -Wno-shadow \ | |
| -Wno-shorten-64-to-32 -Wno-conversion -Wno-conditional-uninitialized" | |
| #library_flags="$(pkg-config --libs --cflags glfw3) -framework OpenGL -I./nanovg -I./nanovg_data" | |
| #additional_sources="nanovg/*.c nanovg_data/demo.c nanovg_data/perf.c" | |
| test -f $outfile | |
| compile_result=$? | |
| if [ "$1" != "--just-run" ]; then | |
| echo compiling... | |
| $compiler_command -x c++ $CFLAGS $default_compiler_flags $0 $additional_sources $library_flags -o "$outfile" | |
| compile_result=$? | |
| echo done compiling | |
| fi | |
| if [ "$compile_result" == "0" ]; then | |
| if [ "$1" != "--just-compile" ]; then | |
| $outfile | |
| exit $? | |
| fi | |
| else | |
| if [ "$1" == "--just-run" ]; then | |
| echo $outfile not found | |
| fi | |
| fi | |
| exit $compile_result | |
| #endif | |
| #include <cstdio> | |
| int main() | |
| { | |
| std::printf("hello shell\n"); | |
| return 0; | |
| } |
| ;; (require 'projectile) | |
| (defun my/prompt-save-buffer () | |
| "Kinda like `save-some-buffers' except it only prompts for the current buffer." | |
| (when (buffer-modified-p) | |
| (map-y-or-n-p "Save %s ?" (lambda (_) (save-buffer)) (list (buffer-name))))) | |
| (defun my/projectile-compile-and-run (arg &optional dir) | |
| "Build and run projectile project. Concatenates | |
| `projectile-compilation-command' and `projectile-run-command' | |
| with a && like so: | |
| \"($projectile-compilation-command) && ($projectile-run-command)\" | |
| It's otherwise equivalent to the execution of those two | |
| functions. You have to confirm each command string." | |
| (interactive "P") | |
| (when (projectile-project-p) | |
| (let* ((project-root (projectile-project-root)) | |
| (default-directory (or dir (projectile-compilation-dir))) | |
| (default-compile-cmd (projectile-compilation-command default-directory)) | |
| (compile-cmd (projectile-maybe-read-command arg default-compile-cmd "Compile command: ")) | |
| (default-run-cmd (projectile-run-command project-root)) | |
| (run-cmd (projectile-maybe-read-command arg default-run-cmd "Run command: ")) | |
| (final-cmd (concat "("compile-cmd ") && (" run-cmd ")"))) | |
| (puthash default-directory compile-cmd projectile-compilation-cmd-map) | |
| (puthash project-root run-cmd projectile-run-cmd-map) | |
| (save-some-buffers (not compilation-ask-about-save) | |
| (lambda () | |
| (projectile-project-buffer-p (current-buffer) | |
| project-root))) | |
| ;; Pass a lambda to projectile-run-compilation so that we can add | |
| ;; the `t' parameter to `compilation-start', which ruyns the | |
| ;; compilation buffer under `comint-mode' mode, so it can read | |
| ;; keyboard input. | |
| (projectile-run-compilation (lambda () (compilation-start final-cmd t)))))) | |
| (defun my/try-build-run-project () | |
| "A sort of catch-all for build & run systems. Only handles | |
| projectile via `my/projectile-compile-and-run' right now, but could add more." | |
| (interactive) | |
| (hack-dir-local-variables-non-file-buffer) | |
| (let ((file-name (buffer-file-name))) | |
| (cond | |
| ((and (projectile-project-p) (not (equal projectile-project-run-cmd 'project-self-run))) | |
| (let ((project-root (projectile-project-root))) | |
| (if (and (projectile-compilation-command project-root) | |
| (projectile-run-command project-root)) | |
| (call-interactively #'my/projectile-compile-and-run) | |
| (message "No compile/run commands defined for this project.")))) | |
| ((and file-name (file-executable-p file-name)) | |
| (my/prompt-save-buffer) | |
| (compilation-start file-name t)) | |
| (nil (message "Not in a project and current buffer not executable"))))) | |
| (defun my/try-build-project () | |
| "Like `my/try-build-run-project', but only for building." | |
| (interactive) | |
| (hack-dir-local-variables-non-file-buffer) | |
| (if (not (projectile-project-p)) | |
| (message "Not in a project") | |
| (let ((project-root (projectile-project-root))) | |
| (if (projectile-compilation-command project-root) | |
| (call-interactively #'projectile-compile-project) | |
| (message "No compile command defined for this project."))))) |