[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[elpa] externals/beardbolt 49e2500be1 259/323: Use shorthands so I can j
|
From: |
ELPA Syncer |
|
Subject: |
[elpa] externals/beardbolt 49e2500be1 259/323: Use shorthands so I can just type bb- instead of beardbolt- |
|
Date: |
Thu, 9 Mar 2023 10:58:36 -0500 (EST) |
branch: externals/beardbolt
commit 49e2500be118d086ebd2d77fbf029a48570827d7
Author: João Távora <joaotavora@gmail.com>
Commit: João Távora <joaotavora@gmail.com>
Use shorthands so I can just type bb- instead of beardbolt-
* beardbolt-java.el: use shorthands
* beardbolt.el: use shorthands
---
beardbolt-java.el | 27 +-
beardbolt.el | 1049 +++++++++++++++++++++++++++--------------------------
2 files changed, 542 insertions(+), 534 deletions(-)
diff --git a/beardbolt-java.el b/beardbolt-java.el
index f517ee781a..c22bbe9b58 100644
--- a/beardbolt-java.el
+++ b/beardbolt-java.el
@@ -37,32 +37,32 @@
;;; Code:
;;;; Regexes
-(defvar beardbolt-java-code-start (rx bol (1+ space)
+(defvar bb-java-code-start (rx bol (1+ space)
(group "Code:")))
-(defvar beardbolt-java-line-table-start (rx bol (1+ space)
+(defvar bb-java-line-table-start (rx bol (1+ space)
(group "LineNumberTable:")))
-(defvar beardbolt-java-local-table-start (rx bol (1+ space)
+(defvar bb-java-local-table-start (rx bol (1+ space)
(group "LocalVariableTable:")))
-(defvar beardbolt-java-code (rx bol (group (1+ space)) (group (1+ digit))
+(defvar bb-java-code (rx bol (group (1+ space)) (group (1+ digit))
":" (1+ space) (group (1+ any)) eol))
-(defvar beardbolt-java-line-table (rx bol (1+ space) "line" (1+ space) (group
(1+ digit))
+(defvar bb-java-line-table (rx bol (1+ space) "line" (1+ space) (group (1+
digit))
":" (1+ space) (group (1+ digit))))
;;;; Functions
-(defun beardbolt-java-process-bytecode (asm-lines &optional filter)
+(defun bb-java-process-bytecode (asm-lines &optional filter)
"Process ASM-LINES to add properties refrencing the source code.
Also FILTER \"useless\" lines out, optionally."
(let (result state result-hold code-block code-linum in-bracket)
(dolist (line asm-lines)
(pcase state
('nil ;; We haven't found any special blocks, so look for them and
copy to output
- (when (string-match-p beardbolt-java-code-start line)
+ (when (string-match-p bb-java-code-start line)
(setq state 'code-found)
(push line result)))
('code-found ;; We are past Code: so begin parsing instructions
- (if (string-match-p beardbolt-java-line-table-start line)
+ (if (string-match-p bb-java-line-table-start line)
(setq state 'linum-found)
- (if (and (string-match beardbolt-java-code line)
+ (if (and (string-match bb-java-code line)
(match-string 1 line)
(match-string 2 line)
(match-string 3 line)
@@ -80,14 +80,14 @@ Also FILTER \"useless\" lines out, optionally."
(setq in-bracket nil))
)))
('linum-found ;; We are past LineNumberTable, so begin generating the
src->code table
- (if (string-match-p beardbolt-java-local-table-start line)
+ (if (string-match-p bb-java-local-table-start line)
(progn
(setq state 'localvar-found)
;; Get everything ready for agg
(setq code-block (nreverse code-block))
(setq code-linum (nreverse code-linum)))
- (if (and (string-match beardbolt-java-line-table line)
+ (if (and (string-match bb-java-line-table line)
(match-string 1 line)
(match-string 2 line))
(push (cons (string-to-number (match-string 2 line))
@@ -110,7 +110,7 @@ Also FILTER \"useless\" lines out, optionally."
(when (and current-mapping
(numberp (cdr current-mapping)))
(add-text-properties 0 (length current-line)
- `(beardbolt-src-line ,(cdr
current-mapping)) current-line))
+ `(bb-src-line ,(cdr current-mapping))
current-line))
(push current-line result)))
;; Don't keep agging
(setq code-linum nil
@@ -132,3 +132,6 @@ Also FILTER \"useless\" lines out, optionally."
(provide 'beardbolt-java)
;;; beardbolt-java.el ends here
+;; Local Variables:
+;; read-symbol-shorthands: (("bb-" . "beardbolt-"))
+;; End:
diff --git a/beardbolt.el b/beardbolt.el
index b946ed6b2c..3763331639 100644
--- a/beardbolt.el
+++ b/beardbolt.el
@@ -1,11 +1,11 @@
;;; beardbolt.el --- A compiler output viewer -*- lexical-binding: t; -*-
-;; Copyright (C) 2018-2021 Jay Kamat
-;; Author: Jay Kamat <jaygkamat@gmail.com>
+;; Copyright (C) 2018-2021 Jay Kamat 2022 João Távora
+;; Author: João Távora <joaotavora@gmail.com>
;; Version: 0.1.2
;; Keywords: compilation, tools
-;; URL: http://gitlab.com/jgkamat/beardbolt
-;; Package-Requires: ((emacs "25.1"))
+;; URL: https://github.com/joaotavora/beardbolt
+;; Package-Requires: ((emacs "28.1"))
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU Affero General Public License as published by
@@ -22,8 +22,9 @@
;;; Commentary:
-;; beardbolt is a package to provide assembly or bytecode output for a source
-;; code input file.
+;; beardbolt is a fork of the amazing rmsbolt.el, found at
+;; https://gitlab.com/jgkamat/rmsbolt, a package to provide assembly or
+;; bytecode output for a source code input file.
;;
;; It currently supports: C/C++, OCaml, Haskell, Python, Java, Go, PHP, D,
;; Pony, Zig, Swift, Emacs Lisp, and (limited) Common Lisp.
@@ -83,23 +84,23 @@
"beardbolt customization options"
:group 'applications)
-(defcustom beardbolt-use-overlays t
+(defcustom bb-use-overlays t
"Whether we should use overlays to show matching code."
:type 'boolean
:group 'beardbolt)
-(defcustom beardbolt-goto-match t
+(defcustom bb-goto-match t
"Whether we should goto the match in the other buffer if it is non visible."
:type 'boolean
:group 'beardbolt)
-(defcustom beardbolt-mode-lighter " RMS🗲"
- "Lighter displayed in mode line when function `beardbolt-mode' is active."
+(defcustom bb-mode-lighter " RMS🗲"
+ "Lighter displayed in mode line when function `bb-mode' is active."
:type 'string
:group 'beardbolt)
-(defcustom beardbolt-large-buffer-size 500
+(defcustom bb-large-buffer-size 500
"Number of lines past which a buffer is considred large."
:type 'integer
:group 'beardbolt)
-(defcustom beardbolt-automatic-recompile t
+(defcustom bb-automatic-recompile t
"Whether to automatically save and recompile the source buffer.
This setting is automatically disabled on large buffers, set to
`force' to force-enable it. To only recompile when the buffer is
@@ -111,18 +112,18 @@ manually saved, set to `on-save'."
:group 'beardbolt)
;;;;; Buffer Local Tweakables
-(defcustom beardbolt-disassemble nil
+(defcustom bb-disassemble nil
"Whether we should disassemble an output binary."
:type 'boolean
:safe 'booleanp
:group 'beardbolt)
-(defcustom beardbolt-command nil
+(defcustom bb-command nil
"The base command to run beardbolt from."
:type 'string
;; nil means use default command
:safe (lambda (v) (or (booleanp v) (stringp v)))
:group 'beardbolt)
-(defcustom beardbolt-default-directory nil
+(defcustom bb-default-directory nil
"The default directory to compile from.
This must be an absolute path if set.
Some exporters (such as pony) may not work with this set."
@@ -130,8 +131,8 @@ Some exporters (such as pony) may not work with this set."
;; nil means use default command
:safe (lambda (v) (or (booleanp v) (stringp v)))
:group 'beardbolt)
-(define-obsolete-variable-alias 'beardbolt-intel-x86
- 'beardbolt-asm-format "beardbolt-0.2"
+(define-obsolete-variable-alias 'bb-intel-x86
+ 'bb-asm-format "bb-0.2"
"Sorry about not providing a proper migration for this variable.
Unfortunately the new options aren't a straightforward mapping.
Most likely what you want:
@@ -140,9 +141,9 @@ t -> \"intel\"
nil -> \"att\"
tool defaults -> nil
-This means that if you had beardbolt-intel-x86 set manually, you
+This means that if you had bb-intel-x86 set manually, you
are now getting tool defaults.")
-(defcustom beardbolt-asm-format "intel"
+(defcustom bb-asm-format "intel"
"Which output assembly format to use.
The supported values depend highly on the exporter, but typical
@@ -157,35 +158,35 @@ being set (at worst falling back to nil if passed
\"intel\")."
:type 'string
:safe (lambda (v) (or (booleanp v) (stringp v)))
:group 'beardbolt)
-(defcustom beardbolt-filter-directives t
+(defcustom bb-filter-directives t
"Whether to filter assembly directives."
:type 'boolean
:safe 'booleanp
:group 'beardbolt)
-(defcustom beardbolt-filter-labels t
+(defcustom bb-filter-labels t
"Whether to filter unused labels."
:type 'boolean
:safe 'booleanp
:group 'beardbolt)
-(defcustom beardbolt-filter-comment-only t
+(defcustom bb-filter-comment-only t
"Whether to filter comment-only lines."
:type 'boolean
:safe 'booleanp
:group 'beardbolt)
-(defcustom beardbolt-ignore-binary-limit nil
+(defcustom bb-ignore-binary-limit nil
"Whether to ignore the binary limit. Could hang emacs..."
:type 'boolean
:safe 'booleanp
:group 'beardbolt)
-(defcustom beardbolt-demangle t
+(defcustom bb-demangle t
"Whether to attempt to demangle the resulting assembly."
:type 'boolean
:safe 'booleanp
:group 'beardbolt)
-(defcustom beardbolt-flag-quirks t
+(defcustom bb-flag-quirks t
"Whether to tweak flags to enable as many features as possible.
-In most cases, we will try to honor flags in beardbolt-command as
+In most cases, we will try to honor flags in bb-command as
much as possible. However, some features may be disabled with
some odd combinations of flags. This variable controls
removing/adding flags to handle those cases.
@@ -195,7 +196,7 @@ Note that basic flags to ensure basic usage are always
modified."
:safe 'booleanp
:group 'beardbolt)
-(defcustom beardbolt-after-parse-hook nil
+(defcustom bb-after-parse-hook nil
"Hook after all parsing is done, but before compile command is run.
Exercise caution when setting variables in this hook - doing so
@@ -206,119 +207,119 @@ may not be cleared to default as variables are usually."
;;;; Faces
-(defface beardbolt-current-line-face
+(defface bb-current-line-face
'((t (:weight bold :inherit highlight)))
"Face to fontify the current line for showing matches."
:group 'beardbolt)
;;;; Variables:
-(defvar beardbolt-output-buffer "*beardbolt-output*")
-;; whether beardbolt-mode is enabled.
-(defvar beardbolt-mode)
+(defvar bb-output-buffer "*bb-output*")
+;; whether bb-mode is enabled.
+(defvar bb-mode)
-(defvar beardbolt-hide-compile t)
-(defvar beardbolt-binary-asm-limit 10000)
-(defvar-local beardbolt-line-mapping nil
+(defvar bb-hide-compile t)
+(defvar bb-binary-asm-limit 10000)
+(defvar-local bb-line-mapping nil
"Line mapping hashtable from source lines -> asm lines")
-(defvar-local beardbolt-current-line nil
+(defvar-local bb-current-line nil
"Current line for fontifier.")
-(defvar-local beardbolt--last-point nil
+(defvar-local bb--last-point nil
"Used to detect when the point has moved.")
-(defvar beardbolt-overlays nil
+(defvar bb-overlays nil
"List of overlays to use.")
-(defvar-local beardbolt--rainbow-overlays nil
+(defvar-local bb--rainbow-overlays nil
"List of rainbow overlays to use.")
-(defvar beardbolt-compile-delay 0.4
+(defvar bb-compile-delay 0.4
"Time in seconds to delay before recompiling if there is a change.")
-(defvar beardbolt--automated-compile nil
+(defvar bb--automated-compile nil
"Whether this compile was automated or not.")
-(defvar beardbolt--shell "bash"
+(defvar bb--shell "bash"
"Which shell to prefer if available.
Used to work around inconsistencies in alternative shells.")
-(defvar beardbolt--temp-dir nil
+(defvar bb--temp-dir nil
"Temporary directory to use for compilation and other reasons.
Please DO NOT modify this blindly, as this directory will get
deleted on Emacs exit.")
-(defvar beardbolt-dir nil
+(defvar bb-dir nil
"The directory which beardbolt is installed to.")
(when load-file-name
- (setq beardbolt-dir (file-name-directory load-file-name)))
+ (setq bb-dir (file-name-directory load-file-name)))
-(defvar-local beardbolt-src-buffer nil)
+(defvar-local bb-src-buffer nil)
-(defvar-local beardbolt--real-src-file nil
+(defvar-local bb--real-src-file nil
"If set, the real filename that we compiled from,
probably due to a copy from this file.")
;; FIXME should we be unbinding the list here, or is setting nil good enough.
-(defvar-local beardbolt--default-variables nil
+(defvar-local bb--default-variables nil
"A list of the buffer-local variables we filled in with defaults.
-Useful for determining if the user overrode things like `beardbolt-command'.
+Useful for determining if the user overrode things like `bb-command'.
This list of variables will automatically be restored to nil.")
-(defvar-local beardbolt-objdump-binary "objdump"
- "A binary to use for objdumping when using `beardbolt-disassemble'.
+(defvar-local bb-objdump-binary "objdump"
+ "A binary to use for objdumping when using `bb-disassemble'.
Useful if you have multiple objdumpers and want to select between them")
;;;; Variable-like funcs
-(defun beardbolt-output-filename (src-buffer &optional asm)
+(defun bb-output-filename (src-buffer &optional asm)
"Function for generating an output filename for SRC-BUFFER.
Outputs assembly file if ASM.
This function does NOT quote the return value for use in inferior shells."
(if (and (not asm)
- (buffer-local-value 'beardbolt-disassemble src-buffer))
- (expand-file-name "beardbolt.out" beardbolt--temp-dir)
- (expand-file-name "beardbolt.s" beardbolt--temp-dir)))
+ (buffer-local-value 'bb-disassemble src-buffer))
+ (expand-file-name "beardbolt.out" bb--temp-dir)
+ (expand-file-name "beardbolt.s" bb--temp-dir)))
;;;; Regexes
-(defvar beardbolt-label-def (rx bol (group (any ".a-zA-Z_$@")
+(defvar bb-label-def (rx bol (group (any ".a-zA-Z_$@")
(0+ (any "a-zA-Z0-9$_@.")))
":"))
-(defvar beardbolt-defines-global (rx bol (0+ space) ".glob"
+(defvar bb-defines-global (rx bol (0+ space) ".glob"
(opt "a") "l" (0+ space)
(group (any ".a-zA-Z_")
(0+ (any "a-zA-Z0-9$_.")))))
-(defvar beardbolt-label-find (rx (any ".a-zA-Z_")
+(defvar bb-label-find (rx (any ".a-zA-Z_")
(0+
(any "a-zA-Z0-9$_."))))
-(defvar beardbolt-assignment-def (rx bol (0+ space)
+(defvar bb-assignment-def (rx bol (0+ space)
(group (any ".a-zA-Z_$")
(1+ (any "a-zA-Z0-9$_.")))
(0+ space) "="))
-(defvar beardbolt-has-opcode (rx bol (0+ space)
+(defvar bb-has-opcode (rx bol (0+ space)
(any "a-zA-Z")))
-(defvar beardbolt-defines-function (rx bol (0+ space) ".type"
+(defvar bb-defines-function (rx bol (0+ space) ".type"
(0+ any) "," (0+ space) (any "@%")
"function" eol))
-(defvar beardbolt-data-defn (rx bol (0+ space) "."
+(defvar bb-data-defn (rx bol (0+ space) "."
(group (or "string" "asciz" "ascii"
(and
(optional (any "1248")) "byte")
"short" "word" "long" "quad" "value"
"zero"))))
-(defvar beardbolt-directive (rx bol (0+ space) "." (0+ any) eol))
-(defvar beardbolt-endblock (rx "." (or "cfi_endproc" "data" "text" "section")))
-(defvar beardbolt-comment-only (rx bol (0+ space) (or (and (or (any "#@;")
"//"))
+(defvar bb-directive (rx bol (0+ space) "." (0+ any) eol))
+(defvar bb-endblock (rx "." (or "cfi_endproc" "data" "text" "section")))
+(defvar bb-comment-only (rx bol (0+ space) (or (and (or (any "#@;") "//"))
(and "/*" (0+ any) "*/"))
(0+ any) eol))
-(defvar beardbolt-disass-line (rx bol
+(defvar bb-disass-line (rx bol
(group "/" (1+ (not (any ":")))) ":"
(group (1+ num))
(0+ any)))
-(defvar beardbolt-disass-label (rx bol (group (1+ (any digit "a-f")))
+(defvar bb-disass-label (rx bol (group (1+ (any digit "a-f")))
(1+ space) "<"
(group (1+ (not (any ">")))) ">:" eol))
-(defvar beardbolt-disass-dest (rx (0+ any) (group (1+ (any digit "a-f")))
+(defvar bb-disass-dest (rx (0+ any) (group (1+ (any digit "a-f")))
(1+ space) "<" (group (1+ (not (any ">"))))
">" eol))
-(defvar beardbolt-disass-opcode (rx bol (0+ space) (group (1+ (any digit
"a-f")))
+(defvar bb-disass-opcode (rx bol (0+ space) (group (1+ (any digit "a-f")))
":" (0+ space)
(group (1+
(repeat 2
@@ -326,24 +327,25 @@ This function does NOT quote the return value for use in
inferior shells."
(opt " ")))
(0+ space)
(group (0+ any))))
-(defvar beardbolt-source-file (rx bol (0+ space) ".file" (1+ space)
+(defvar bb-source-file (rx bol (0+ space) ".file" (1+ space)
(group (1+ digit)) (1+ space) ?\"
(group (1+ (not (any ?\")))) ?\"
(opt (1+ space) ?\"
(group (1+ (not (any ?\")))) ?\")
(0+ any)))
-(defvar beardbolt-source-tag (rx bol (0+ space) ".loc" (1+ space)
+(defvar bb-source-tag (rx bol (0+ space) ".loc" (1+ space)
(group (1+ digit)) (1+ space)
(group (1+ digit))
(0+ any)))
-(defvar beardbolt-source-stab (rx bol (0+ any) ".stabn" (1+ space)
+(defvar bb-source-stab (rx bol (0+ any) ".stabn" (1+ space)
(group (1+ digit)) ",0,"
(group (1+ digit)) "," (0+ any)))
;;;; Classes
-(cl-defstruct (beardbolt-lang
- (:conc-name beardbolt-l-))
+(cl-defstruct (bb-lang
+ (:constructor make-beardbolt-lang)
+ (:conc-name bb-l-))
(supports-disass
nil
:type 'bool
@@ -374,7 +376,7 @@ the compile command.")
(default-directory
nil
:type 'string
- :documentation "Default directory to run compilation in. By default, use
beardbolt--temp-dir.
+ :documentation "Default directory to run compilation in. By default, use
bb--temp-dir.
If provided a function, call that function with the source buffer to determine
the default directory.")
(compile-cmd-function
@@ -392,12 +394,12 @@ the default directory.")
:type 'function
:documentation "A custom function to run instead of running any compilation
command.
Generally not useful with the sole exception of the emacs lisp disassembler.
-This function is responsible for calling `beardbolt--handle-finish-compile'
+This function is responsible for calling `bb--handle-finish-compile'
Please be careful when setting this, as it bypasses most logic and is
generally not useful."))
;;;; Helper Functions
-(defmacro beardbolt--with-files (src-buffer &rest body)
+(defmacro bb--with-files (src-buffer &rest body)
"Execute BODY with `src-filename' and `output-filename' defined.
Args taken from SRC-BUFFER.
Return value is quoted for passing to the shell."
@@ -405,21 +407,21 @@ Return value is quoted for passing to the shell."
(buffer-file-name)))
(output-filename
(shell-quote-argument
- (beardbolt-output-filename ,src-buffer))))
+ (bb-output-filename ,src-buffer))))
,@body))
-(defmacro beardbolt--set-local (var val)
+(defmacro bb--set-local (var val)
"Set unquoted variable VAR to value VAL in current buffer."
(declare (debug (symbolp form)))
`(set (make-local-variable ,var) ,val))
-(defun beardbolt-split-rm-single (cmd flag &optional test)
+(defun bb-split-rm-single (cmd flag &optional test)
"Remove a single FLAG from CMD. Test according to TEST."
(mapconcat #'identity (cl-remove flag (split-string cmd)
:test (or test #'string=))
" "))
-(defun beardbolt-split-rm-double (cmd flag)
+(defun bb-split-rm-double (cmd flag)
"Remove a single FLAG and arg from CMD."
(cl-loop while split with split = (split-string cmd)
for i from 0
@@ -432,26 +434,26 @@ Return value is quoted for passing to the shell."
;;;; Language Functions
;;;;; Compile Commands
-(defun beardbolt--c-quirks (cmd &key src-buffer)
+(defun bb--c-quirks (cmd &key src-buffer)
"Handle quirks in CMD, and return unchanged or modified CMD.
Use SRC-BUFFER as buffer for local variables."
- (if (and (buffer-local-value 'beardbolt-flag-quirks src-buffer)
+ (if (and (buffer-local-value 'bb-flag-quirks src-buffer)
(string-match-p (rx "-save-temps") cmd)
(string-match-p (rx "-P") cmd))
- (beardbolt-split-rm-single cmd "-save-temps")
+ (bb-split-rm-single cmd "-save-temps")
cmd))
-(cl-defun beardbolt--c-compile-cmd (&key src-buffer)
+(cl-defun bb--c-compile-cmd (&key src-buffer)
"Process a compile command for gcc/clang."
- (beardbolt--with-files
+ (bb--with-files
src-buffer
(let* ( ;; Turn off passing the source file if we find compile_commands
- (no-src-filename (beardbolt--handle-c-compile-cmd src-buffer))
- (asm-format (buffer-local-value 'beardbolt-asm-format src-buffer))
- (disass (buffer-local-value 'beardbolt-disassemble src-buffer))
- (cmd (buffer-local-value 'beardbolt-command src-buffer))
+ (no-src-filename (bb--handle-c-compile-cmd src-buffer))
+ (asm-format (buffer-local-value 'bb-asm-format src-buffer))
+ (disass (buffer-local-value 'bb-disassemble src-buffer))
+ (cmd (buffer-local-value 'bb-command src-buffer))
(cmd (mapconcat #'identity
(list cmd
"-g"
@@ -466,23 +468,23 @@ Use SRC-BUFFER as buffer for local variables."
(not disass))
(concat "-masm=" asm-format)))
" "))
- (cmd (beardbolt--c-quirks cmd :src-buffer src-buffer)))
+ (cmd (bb--c-quirks cmd :src-buffer src-buffer)))
cmd)))
-(cl-defun beardbolt--ocaml-compile-cmd (&key src-buffer)
+(cl-defun bb--ocaml-compile-cmd (&key src-buffer)
"Process a compile command for ocaml.
Needed as ocaml cannot output asm to a non-hardcoded file"
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (let* ((diss (buffer-local-value 'beardbolt-disassemble src-buffer))
+ (let* ((diss (buffer-local-value 'bb-disassemble src-buffer))
(predicted-asm-filename (shell-quote-argument
(concat (file-name-sans-extension
(buffer-file-name)) ".s")))
- (cmd (buffer-local-value 'beardbolt-command src-buffer))
+ (cmd (buffer-local-value 'bb-command src-buffer))
(cmd (mapconcat #'identity
(list cmd
"-g"
- (if (buffer-local-value 'beardbolt-disassemble
src-buffer)
+ (if (buffer-local-value 'bb-disassemble
src-buffer)
""
"-S")
src-filename
@@ -499,13 +501,13 @@ Use SRC-BUFFER as buffer for local variables."
" "))
" ")))
cmd)))
-(cl-defun beardbolt--lisp-compile-cmd (&key src-buffer)
+(cl-defun bb--lisp-compile-cmd (&key src-buffer)
"Process a compile command for common lisp.
Assumes function name to disassemble is \\='main\\='."
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (let* ((cmd (buffer-local-value 'beardbolt-command src-buffer))
+ (let* ((cmd (buffer-local-value 'bb-command src-buffer))
(interpreter (cl-first (split-string cmd nil t)))
(disass-eval "\"(disassemble 'main)\"")
(disass-eval-unquoted "(disassemble 'main)"))
@@ -528,13 +530,13 @@ Use SRC-BUFFER as buffer for local variables."
" "))
(_
(error "This Common Lisp interpreter is not supported"))))))
-(cl-defun beardbolt--rust-compile-cmd (&key src-buffer)
+(cl-defun bb--rust-compile-cmd (&key src-buffer)
"Process a compile command for rustc."
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (let* ((asm-format (buffer-local-value 'beardbolt-asm-format src-buffer))
- (disass (buffer-local-value 'beardbolt-disassemble src-buffer))
- (cmd (buffer-local-value 'beardbolt-command src-buffer))
+ (let* ((asm-format (buffer-local-value 'bb-asm-format src-buffer))
+ (disass (buffer-local-value 'bb-disassemble src-buffer))
+ (cmd (buffer-local-value 'bb-command src-buffer))
(cmd (mapconcat #'identity
(list cmd
"-g"
@@ -549,11 +551,11 @@ Use SRC-BUFFER as buffer for local variables."
(concat "-Cllvm-args=--x86-asm-syntax="
asm-format)))
" ")))
cmd)))
-(cl-defun beardbolt--go-compile-cmd (&key src-buffer)
+(cl-defun bb--go-compile-cmd (&key src-buffer)
"Process a compile command for go."
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (let* ((cmd (buffer-local-value 'beardbolt-command src-buffer))
+ (let* ((cmd (buffer-local-value 'bb-command src-buffer))
(cmd (mapconcat #'identity
(list cmd
"tool" "compile"
@@ -562,21 +564,21 @@ Use SRC-BUFFER as buffer for local variables."
src-filename)
" ")))
cmd)))
-(cl-defun beardbolt--d-compile-cmd (&key src-buffer)
+(cl-defun bb--d-compile-cmd (&key src-buffer)
"Process a compile command for d"
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (let* ((compiler (buffer-local-value 'beardbolt-command src-buffer))
+ (let* ((compiler (buffer-local-value 'bb-command src-buffer))
(cmd (mapconcat
#'identity
(list compiler "-g" "-output-s" src-filename "-of"
output-filename)
" ")))
cmd)))
-(cl-defun beardbolt--pony-compile-cmd (&key src-buffer)
+(cl-defun bb--pony-compile-cmd (&key src-buffer)
"Process a compile command for ponyc."
- (let* ((cmd (buffer-local-value 'beardbolt-command src-buffer))
- (dir (expand-file-name "pony/" beardbolt--temp-dir))
+ (let* ((cmd (buffer-local-value 'bb-command src-buffer))
+ (dir (expand-file-name "pony/" bb--temp-dir))
(_ (make-directory dir t))
;; (base-filename (file-name-sans-extension
;; (file-name-nondirectory
@@ -588,13 +590,13 @@ Use SRC-BUFFER as buffer for local variables."
;; TODO should we copy this in lisp here, or pass this to the
compilation command?
(_ (copy-file (buffer-file-name)
(expand-file-name dir) t))
- (dis (buffer-local-value 'beardbolt-disassemble src-buffer))
+ (dis (buffer-local-value 'bb-disassemble src-buffer))
(cmd (mapconcat #'identity
(list
"cd" dir "&&"
cmd
"-g"
- ;; FIXME: test this properly and use
beardbolt-asm-format to expose it.
+ ;; FIXME: test this properly and use bb-asm-format
to expose it.
(if dis
"-r=obj"
"-r=asm")
@@ -602,75 +604,75 @@ Use SRC-BUFFER as buffer for local variables."
"&&" "mv"
(if dis object-filename asm-filename)
(shell-quote-argument
- (beardbolt-output-filename src-buffer)))
+ (bb-output-filename src-buffer)))
" ")))
(with-current-buffer src-buffer
- (setq beardbolt--real-src-file
+ (setq bb--real-src-file
(expand-file-name (file-name-nondirectory
(buffer-file-name))
dir)))
cmd))
-(cl-defun beardbolt--py-compile-cmd (&key src-buffer)
+(cl-defun bb--py-compile-cmd (&key src-buffer)
"Process a compile command for python3."
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (let* ((cmd (buffer-local-value 'beardbolt-command src-buffer)))
+ (let* ((cmd (buffer-local-value 'bb-command src-buffer)))
(mapconcat #'identity
(list cmd "-m" "dis" src-filename
">" output-filename)
" "))))
-(defun beardbolt--hack-p (src-buffer)
+(defun bb--hack-p (src-buffer)
"Return non-nil if SRC-BUFFER should should use hhvm instead of php."
(with-current-buffer src-buffer
(save-excursion
(goto-char (point-min))
(re-search-forward (rx "<?hh") nil t))))
-(defun beardbolt--php-default-compile-cmd (src-buffer)
+(defun bb--php-default-compile-cmd (src-buffer)
"Return the default php compile command for SRC-BUFFER."
- (if (beardbolt--hack-p src-buffer)
+ (if (bb--hack-p src-buffer)
"hh_single_compile"
"php"))
-(cl-defun beardbolt--php-compile-cmd (&key src-buffer)
+(cl-defun bb--php-compile-cmd (&key src-buffer)
"Process a compile command for PHP.
In order to disassemble opcdoes, we need to have the vld.so
extension to php on.
https://github.com/derickr/vld";
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (if (beardbolt--hack-p src-buffer)
- (concat (buffer-local-value 'beardbolt-command src-buffer)
+ (if (bb--hack-p src-buffer)
+ (concat (buffer-local-value 'bb-command src-buffer)
" " src-filename " > " output-filename)
- (concat (buffer-local-value 'beardbolt-command src-buffer)
+ (concat (buffer-local-value 'bb-command src-buffer)
" -dvld.active=1 -dvld.execute=0 -dvld.verbosity=1 "
src-filename " 2> " output-filename " > /dev/null"))))
-(cl-defun beardbolt--hs-compile-cmd (&key src-buffer)
+(cl-defun bb--hs-compile-cmd (&key src-buffer)
"Process a compile command for ghc."
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (let* ((cmd (buffer-local-value 'beardbolt-command src-buffer))
+ (let* ((cmd (buffer-local-value 'bb-command src-buffer))
(cmd (mapconcat #'identity
(list cmd
"-g"
- (if (buffer-local-value 'beardbolt-disassemble
src-buffer)
+ (if (buffer-local-value 'bb-disassemble
src-buffer)
""
"-S")
src-filename
"-o" output-filename)
" ")))
cmd)))
-(cl-defun beardbolt--java-compile-cmd (&key src-buffer)
+(cl-defun bb--java-compile-cmd (&key src-buffer)
"Process a compile command for ocaml.
Needed as ocaml cannot output asm to a non-hardcoded file"
- (beardbolt--with-files
+ (bb--with-files
src-buffer
(let* ((class-filename (shell-quote-argument
(concat (file-name-sans-extension
(buffer-file-name)) ".class")))
- (cmd (buffer-local-value 'beardbolt-command src-buffer))
+ (cmd (buffer-local-value 'bb-command src-buffer))
(cmd (mapconcat #'identity
(list cmd
"-g"
@@ -684,19 +686,19 @@ https://github.com/derickr/vld";
" ")))
cmd)))
-(cl-defun beardbolt--elisp-compile-override (&key src-buffer)
+(cl-defun bb--elisp-compile-override (&key src-buffer)
(let ((file-name (buffer-file-name)))
(with-temp-buffer
- (beardbolt--disassemble-file file-name (current-buffer))
- (beardbolt--handle-finish-compile src-buffer nil :override-buffer
(current-buffer)))))
+ (bb--disassemble-file file-name (current-buffer))
+ (bb--handle-finish-compile src-buffer nil :override-buffer
(current-buffer)))))
-(cl-defun beardbolt--nim-compile-cmd (&key src-buffer)
+(cl-defun bb--nim-compile-cmd (&key src-buffer)
"Process a compile command for nim."
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (let* ((cmd (buffer-local-value 'beardbolt-command src-buffer))
+ (let* ((cmd (buffer-local-value 'bb-command src-buffer))
(cmd
- (let* ((outdir (expand-file-name "nim-cache" beardbolt--temp-dir)))
+ (let* ((outdir (expand-file-name "nim-cache" bb--temp-dir)))
(string-join
(list cmd
"--debugger:native"
@@ -713,16 +715,16 @@ https://github.com/derickr/vld";
" "))))
cmd)))
-(cl-defun beardbolt--zig-compile-cmd (&key src-buffer)
+(cl-defun bb--zig-compile-cmd (&key src-buffer)
"Process a compile command for zig."
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (let* ((disass (buffer-local-value 'beardbolt-disassemble src-buffer))
- (cmd (buffer-local-value 'beardbolt-command src-buffer))
+ (let* ((disass (buffer-local-value 'bb-disassemble src-buffer))
+ (cmd (buffer-local-value 'bb-command src-buffer))
(cmd (string-join
(list cmd
src-filename
- "--cache-dir" (expand-file-name "zig-cache"
beardbolt--temp-dir)
+ "--cache-dir" (expand-file-name "zig-cache" bb--temp-dir)
(concat (if disass
"-femit-bin="
"-fno-emit-bin -femit-asm=")
@@ -730,12 +732,12 @@ https://github.com/derickr/vld";
" ")))
cmd)))
-(cl-defun beardbolt--swift-compile-cmd (&key src-buffer)
+(cl-defun bb--swift-compile-cmd (&key src-buffer)
"Process a compile command for swiftc."
- (beardbolt--with-files
+ (bb--with-files
src-buffer
- (let* ((asm-format (buffer-local-value 'beardbolt-asm-format src-buffer))
- (cmd (buffer-local-value 'beardbolt-command src-buffer))
+ (let* ((asm-format (buffer-local-value 'bb-asm-format src-buffer))
+ (cmd (buffer-local-value 'bb-command src-buffer))
(cmd (mapconcat #'identity
(list cmd
"-g"
@@ -749,7 +751,7 @@ https://github.com/derickr/vld";
;;;;; Hidden Function Definitions
-(defvar beardbolt--hidden-func-c
+(defvar bb--hidden-func-c
(rx bol (or (and "__" (0+ any))
(and "_" (or "init" "start" "fini"))
(and (opt "de") "register_tm_clones")
@@ -757,7 +759,7 @@ https://github.com/derickr/vld";
"frame_dummy"
(and ".plt" (0+ any)))
eol))
-(defvar beardbolt--hidden-func-ocaml
+(defvar bb--hidden-func-ocaml
(rx bol
(or (and "__" (0+ any))
(and "_" (or "init" "start" "fini"))
@@ -773,7 +775,7 @@ https://github.com/derickr/vld";
;; filter out any lowercase
(and (1+ (1+ lower) (opt (or "64" "32" "8" "16")) (opt "_"))))
eol))
-(defvar beardbolt--hidden-func-zig
+(defvar bb--hidden-func-zig
(rx bol (or (and "_" (0+ any))
(and (opt "de") "register_tm_clones")
"call_gmon_start"
@@ -783,19 +785,19 @@ https://github.com/derickr/vld";
;;;;; Demangling Functions
-(defun beardbolt--path-to-swift-demangler ()
+(defun bb--path-to-swift-demangler ()
"Return the path to the configured Swift demangler, depending
on the active toolchain."
- (beardbolt--path-to-swift-tool "swift-demangle"))
+ (bb--path-to-swift-tool "swift-demangle"))
;;;;; Language Integrations
-(defun beardbolt--path-to-swift-compiler ()
+(defun bb--path-to-swift-compiler ()
"Return the path to the configured Swift compiler, depending on
the active toolchain."
- (beardbolt--path-to-swift-tool "swiftc"))
+ (bb--path-to-swift-tool "swiftc"))
-(defun beardbolt--path-to-swift-tool (swift-tool)
+(defun bb--path-to-swift-tool (swift-tool)
"Return the path to SWIFT-TOOL, depending on the active
toolchain."
(let* ((swift-tool-binary swift-tool)
@@ -810,7 +812,7 @@ toolchain."
swift-tool-toolchain-path)
(t nil))))
-(defun beardbolt--parse-compile-commands (comp-cmds file)
+(defun bb--parse-compile-commands (comp-cmds file)
"Parse COMP-CMDS and extract a compilation dir and command for FILE."
(when-let ((json-object-type 'alist)
(json-array-type 'vector)
@@ -826,168 +828,168 @@ toolchain."
(dir (alist-get 'directory entry))
(cmd (alist-get 'command entry)))
(list dir cmd)))
-(defun beardbolt--handle-c-compile-cmd (src-buffer)
+(defun bb--handle-c-compile-cmd (src-buffer)
"Handle compile_commands.json for c/c++ for a given SRC-BUFFER.
return t if successful."
- (when-let ((defaults (buffer-local-value 'beardbolt--default-variables
src-buffer))
- (default-dir (cl-find 'beardbolt-default-directory defaults))
- (default-cmd (cl-find 'beardbolt-command defaults))
+ (when-let ((defaults (buffer-local-value 'bb--default-variables src-buffer))
+ (default-dir (cl-find 'bb-default-directory defaults))
+ (default-cmd (cl-find 'bb-command defaults))
(ccj "compile_commands.json")
(compile-cmd-file
(locate-dominating-file
(buffer-file-name src-buffer)
ccj))
(compile-cmd-file (expand-file-name ccj compile-cmd-file))
- (to-ret (beardbolt--parse-compile-commands
+ (to-ret (bb--parse-compile-commands
compile-cmd-file (buffer-file-name src-buffer))))
(with-current-buffer src-buffer
- (setq-local beardbolt-default-directory (file-name-as-directory
(cl-first to-ret)))
- (setq-local beardbolt-command
+ (setq-local bb-default-directory (file-name-as-directory (cl-first
to-ret)))
+ (setq-local bb-command
;; Remove -c, -S, and -o <arg> if present,
;; as we will add them back
;; Remove args starting with -flto, as -flto breaks asm
output.
(thread-first (cl-second to-ret)
- (beardbolt-split-rm-single "-c")
- (beardbolt-split-rm-single "-S")
- (beardbolt-split-rm-single "-flto" #'string-prefix-p)
- (beardbolt-split-rm-double "-o")))
+ (bb-split-rm-single "-c")
+ (bb-split-rm-single "-S")
+ (bb-split-rm-single "-flto" #'string-prefix-p)
+ (bb-split-rm-double "-o")))
t)))
;;;; Language Definitions
-(defvar beardbolt-languages)
+(defvar bb-languages)
(setq
- beardbolt-languages
+ bb-languages
`((c-mode
. ,(make-beardbolt-lang :compile-cmd "gcc"
- :supports-asm t
- :supports-disass t
- :demangler "c++filt"
- :compile-cmd-function #'beardbolt--c-compile-cmd
- :disass-hidden-funcs beardbolt--hidden-func-c))
+ :supports-asm t
+ :supports-disass t
+ :demangler "c++filt"
+ :compile-cmd-function #'bb--c-compile-cmd
+ :disass-hidden-funcs bb--hidden-func-c))
(c++-mode
. ,(make-beardbolt-lang :compile-cmd "g++"
- :supports-asm t
- :supports-disass t
- :demangler "c++filt"
- :compile-cmd-function #'beardbolt--c-compile-cmd
- :disass-hidden-funcs beardbolt--hidden-func-c))
+ :supports-asm t
+ :supports-disass t
+ :demangler "c++filt"
+ :compile-cmd-function #'bb--c-compile-cmd
+ :disass-hidden-funcs bb--hidden-func-c))
(d-mode
. ,(make-beardbolt-lang :compile-cmd "ldc2"
- :supports-asm t
- :supports-disass nil
- :demangler "ddemangle"
- :compile-cmd-function #'beardbolt--d-compile-cmd))
+ :supports-asm t
+ :supports-disass nil
+ :demangler "ddemangle"
+ :compile-cmd-function #'bb--d-compile-cmd))
;; In order to parse ocaml files, you need the emacs ocaml mode, tuareg
(tuareg-mode
. ,(make-beardbolt-lang :compile-cmd "ocamlopt"
- :supports-asm t
- :supports-disass t
- :compile-cmd-function #'beardbolt--ocaml-compile-cmd
- :disass-hidden-funcs beardbolt--hidden-func-ocaml))
+ :supports-asm t
+ :supports-disass t
+ :compile-cmd-function #'bb--ocaml-compile-cmd
+ :disass-hidden-funcs bb--hidden-func-ocaml))
(lisp-mode
. ,(make-beardbolt-lang :compile-cmd "sbcl"
- :supports-asm t
- :supports-disass nil
- :objdumper 'cat
- :compile-cmd-function #'beardbolt--lisp-compile-cmd))
+ :supports-asm t
+ :supports-disass nil
+ :objdumper 'cat
+ :compile-cmd-function #'bb--lisp-compile-cmd))
(rust-mode
. ,(make-beardbolt-lang :compile-cmd "rustc"
- :supports-asm t
- :supports-disass nil
- :objdumper 'objdump
- :demangler "rustfilt"
- :compile-cmd-function #'beardbolt--rust-compile-cmd))
+ :supports-asm t
+ :supports-disass nil
+ :objdumper 'objdump
+ :demangler "rustfilt"
+ :compile-cmd-function #'bb--rust-compile-cmd))
;; Copy of above
(rustic-mode
. ,(make-beardbolt-lang :compile-cmd "rustc"
- :supports-asm t
- :supports-disass nil
- :objdumper 'objdump
- :demangler "rustfilt"
- :compile-cmd-function #'beardbolt--rust-compile-cmd))
+ :supports-asm t
+ :supports-disass nil
+ :objdumper 'objdump
+ :demangler "rustfilt"
+ :compile-cmd-function #'bb--rust-compile-cmd))
(ponylang-mode
. ,(make-beardbolt-lang :compile-cmd "ponyc"
- :supports-asm t
- :supports-disass t
- :objdumper 'objdump
- :compile-cmd-function #'beardbolt--pony-compile-cmd))
+ :supports-asm t
+ :supports-disass t
+ :objdumper 'objdump
+ :compile-cmd-function #'bb--pony-compile-cmd))
(php-mode
- . ,(make-beardbolt-lang :compile-cmd #'beardbolt--php-default-compile-cmd
- :supports-asm t
- :supports-disass nil
- :compile-cmd-function #'beardbolt--php-compile-cmd
- :process-asm-custom-fn
#'beardbolt--process-php-bytecode))
+ . ,(make-beardbolt-lang :compile-cmd #'bb--php-default-compile-cmd
+ :supports-asm t
+ :supports-disass nil
+ :compile-cmd-function #'bb--php-compile-cmd
+ :process-asm-custom-fn #'bb--process-php-bytecode))
;; ONLY SUPPORTS PYTHON 3
(python-mode
. ,(make-beardbolt-lang :compile-cmd "python3"
- :supports-asm t
- :supports-disass nil
- :compile-cmd-function #'beardbolt--py-compile-cmd
- :process-asm-custom-fn
#'beardbolt--process-python-bytecode))
+ :supports-asm t
+ :supports-disass nil
+ :compile-cmd-function #'bb--py-compile-cmd
+ :process-asm-custom-fn
#'bb--process-python-bytecode))
(haskell-mode
. ,(make-beardbolt-lang :compile-cmd "ghc"
- :supports-asm t
- :supports-disass nil
- :demangler "haskell-demangler"
- :compile-cmd-function #'beardbolt--hs-compile-cmd))
+ :supports-asm t
+ :supports-disass nil
+ :demangler "haskell-demangler"
+ :compile-cmd-function #'bb--hs-compile-cmd))
(java-mode
. ,(make-beardbolt-lang :compile-cmd "javac"
- :supports-asm t
- :supports-disass nil
- :objdumper 'cat
- :compile-cmd-function #'beardbolt--java-compile-cmd
- :process-asm-custom-fn
#'beardbolt--process-java-bytecode))
+ :supports-asm t
+ :supports-disass nil
+ :objdumper 'cat
+ :compile-cmd-function #'bb--java-compile-cmd
+ :process-asm-custom-fn
#'bb--process-java-bytecode))
(emacs-lisp-mode
. ,(make-beardbolt-lang :supports-asm t
- :supports-disass nil
- ;; Nop
- :process-asm-custom-fn (lambda (_src-buffer lines)
- lines)
- :elisp-compile-override
#'beardbolt--elisp-compile-override))
+ :supports-disass nil
+ ;; Nop
+ :process-asm-custom-fn (lambda (_src-buffer lines)
+ lines)
+ :elisp-compile-override
#'bb--elisp-compile-override))
(nim-mode
. ,(make-beardbolt-lang :compile-cmd "nim c"
- :supports-disass t
- :objdumper 'objdump
- :demangler "c++filt"
- :compile-cmd-function #'beardbolt--nim-compile-cmd
- :disass-hidden-funcs beardbolt--hidden-func-c))
+ :supports-disass t
+ :objdumper 'objdump
+ :demangler "c++filt"
+ :compile-cmd-function #'bb--nim-compile-cmd
+ :disass-hidden-funcs bb--hidden-func-c))
(zig-mode
. ,(make-beardbolt-lang :compile-cmd "zig build-obj -O ReleaseFast"
- :supports-asm t
- :supports-disass t
- :objdumper 'objdump
- :compile-cmd-function #'beardbolt--zig-compile-cmd
- :disass-hidden-funcs beardbolt--hidden-func-zig))
+ :supports-asm t
+ :supports-disass t
+ :objdumper 'objdump
+ :compile-cmd-function #'bb--zig-compile-cmd
+ :disass-hidden-funcs bb--hidden-func-zig))
(go-mode
. ,(make-beardbolt-lang :compile-cmd "go"
- :supports-asm nil
- :supports-disass t
- :objdumper 'go-objdump
- :compile-cmd-function
#'beardbolt--go-compile-cmd
- :process-asm-custom-fn
#'beardbolt--process-go-asm-lines))
+ :supports-asm nil
+ :supports-disass t
+ :objdumper 'go-objdump
+ :compile-cmd-function #'bb--go-compile-cmd
+ :process-asm-custom-fn #'bb--process-go-asm-lines))
(swift-mode
- . ,(make-beardbolt-lang :compile-cmd (beardbolt--path-to-swift-compiler)
- :supports-asm t
- :supports-disass nil
- :objdumper 'objdump
- :demangler (beardbolt--path-to-swift-demangler)
- :compile-cmd-function
#'beardbolt--swift-compile-cmd))
+ . ,(make-beardbolt-lang :compile-cmd (bb--path-to-swift-compiler)
+ :supports-asm t
+ :supports-disass nil
+ :objdumper 'objdump
+ :demangler (bb--path-to-swift-demangler)
+ :compile-cmd-function #'bb--swift-compile-cmd))
))
-(make-obsolete-variable 'beardbolt-languages
- 'beardbolt-language-descriptor "beardbolt-0.2")
+(make-obsolete-variable 'bb-languages
+ 'bb-language-descriptor "bb-0.2")
-(defvar-local beardbolt-language-descriptor nil
- ;; FIXME: Major modes can't set this without calling `make-beardbolt-lang',
+(defvar-local bb-language-descriptor nil
+ ;; FIXME: Major modes can't set this without calling `make-bb-lang',
;; so it forces them to require `beardbolt', which is a bummer.
"Description of the language tools of current buffer for use by beardbolt.
-This should be an object of type `beardbolt-lang', normally set by the major
mode")
+This should be an object of type `bb-lang', normally set by the major mode")
;;;; Macros
-(defmacro beardbolt-with-display-buffer-no-window (&rest body)
+(defmacro bb-with-display-buffer-no-window (&rest body)
"Run BODY without displaying any window."
;; See http://debbugs.gnu.org/13594
`(let ((display-buffer-overriding-action
- (if beardbolt-hide-compile
+ (if bb-hide-compile
(list #'display-buffer-no-window)
display-buffer-overriding-action)))
,@body))
@@ -996,7 +998,7 @@ This should be an object of type `beardbolt-lang', normally
set by the major mod
;;;; Functions
;; Functions to parse and lint assembly were lifted almost directly from the
compiler-explorer
-(defun beardbolt-re-seq (regexp string)
+(defun bb-re-seq (regexp string)
"Get list of all REGEXP match in STRING."
(save-match-data
(let ((pos 0)
@@ -1009,7 +1011,7 @@ This should be an object of type `beardbolt-lang',
normally set by the major mod
;; Prevent byte-compilation warnings for cl-print-compiled, which is imported
;; from cl-print
(defvar cl-print-compiled)
-(defun beardbolt--disassemble-file (filename out-buffer)
+(defun bb--disassemble-file (filename out-buffer)
"Disassemble an elisp FILENAME into elisp bytecode in OUT-BUFFER.
Lifted from
https://emacs.stackexchange.com/questions/35936/disassembly-of-a-bytecode-file";
(if (not (require 'cl-print nil 'noerror))
@@ -1040,19 +1042,19 @@ Lifted from
https://emacs.stackexchange.com/questions/35936/disassembly-of-a-byt
;; Filtering functions were more or less lifted from the godbolt compiler
explorer to maintain compatiblity.
;; https://github.com/mattgodbolt/compiler-explorer/blob/master/lib/asm.js
-(defun beardbolt--has-opcode-p (line)
+(defun bb--has-opcode-p (line)
"Check if LINE has opcodes."
(save-match-data
- (let* ((match (string-match beardbolt-label-def line))
+ (let* ((match (string-match bb-label-def line))
(line (if match
(substring line (match-end 0))
line))
(line (cl-first (split-string line (rx (1+ (any ";#")))))))
- (if (string-match-p beardbolt-assignment-def line)
+ (if (string-match-p bb-assignment-def line)
nil
- (string-match-p beardbolt-has-opcode line)))))
+ (string-match-p bb-has-opcode line)))))
-(defun beardbolt--find-used-labels (src-buffer asm-lines)
+(defun bb--find-used-labels (src-buffer asm-lines)
"Find used labels in ASM-LINES generated from SRC-BUFFER."
(let ((match nil)
(current-label nil)
@@ -1060,28 +1062,28 @@ Lifted from
https://emacs.stackexchange.com/questions/35936/disassembly-of-a-byt
(weak-usages (make-hash-table :test #'equal)))
(dolist (line asm-lines)
(setq line (string-trim-left line)
- match (and (string-match beardbolt-label-def line)
+ match (and (string-match bb-label-def line)
(match-string 1 line)))
(when match
(setq current-label match))
- (setq match (and (string-match beardbolt-defines-global line)
+ (setq match (and (string-match bb-defines-global line)
(match-string 1 line)))
(when match
(puthash match t labels-used))
;; When we have no line or a period started line, skip
(unless (or (string-empty-p line)
(eq (elt line 0) ?.)
- (not (string-match-p beardbolt-label-find line)))
- (if (or (not (buffer-local-value 'beardbolt-filter-directives
src-buffer))
- (beardbolt--has-opcode-p line)
- (string-match-p beardbolt-defines-function line))
+ (not (string-match-p bb-label-find line)))
+ (if (or (not (buffer-local-value 'bb-filter-directives src-buffer))
+ (bb--has-opcode-p line)
+ (string-match-p bb-defines-function line))
;; Add labels indescriminantly
- (dolist (l (beardbolt-re-seq beardbolt-label-find line))
+ (dolist (l (bb-re-seq bb-label-find line))
(puthash l t labels-used))
(when (and current-label
- (or (string-match-p beardbolt-data-defn line)
- (beardbolt--has-opcode-p line)))
- (dolist (l (beardbolt-re-seq beardbolt-label-find line))
+ (or (string-match-p bb-data-defn line)
+ (bb--has-opcode-p line)))
+ (dolist (l (bb-re-seq bb-label-find line))
(cl-pushnew l (gethash current-label weak-usages) :test
#'equal))))))
(let* ((max-label-iter 10)
@@ -1104,35 +1106,35 @@ Lifted from
https://emacs.stackexchange.com/questions/35936/disassembly-of-a-byt
(setq completed t))))
labels-used)))
-(defun beardbolt--user-func-p (src-buffer func)
+(defun bb--user-func-p (src-buffer func)
"Return t if FUNC is a user function.
Argument SRC-BUFFER source buffer."
(let* ((lang (with-current-buffer src-buffer
- (beardbolt--get-lang)))
- (regexp (beardbolt-l-disass-hidden-funcs lang)))
+ (bb--get-lang)))
+ (regexp (bb-l-disass-hidden-funcs lang)))
(if regexp
(not (string-match-p regexp func))
t)))
;; TODO godbolt does not handle disassembly with filter=off, but we should.
-(cl-defun beardbolt--process-disassembled-lines (src-buffer asm-lines)
+(cl-defun bb--process-disassembled-lines (src-buffer asm-lines)
"Process and filter disassembled ASM-LINES from SRC-BUFFER."
(let* ((src-file-name
- (or (buffer-local-value 'beardbolt--real-src-file src-buffer)
+ (or (buffer-local-value 'bb--real-src-file src-buffer)
(buffer-file-name src-buffer)))
(result nil)
(func nil)
(source-linum nil)
- (def-dir (or (buffer-local-value 'beardbolt-default-directory
src-buffer)
+ (def-dir (or (buffer-local-value 'bb-default-directory src-buffer)
(and src-file-name
(file-name-directory src-file-name)))))
(dolist (line asm-lines)
(catch 'continue
- (when (and (> (length result) beardbolt-binary-asm-limit)
- (not (buffer-local-value 'beardbolt-ignore-binary-limit
src-buffer)))
- (cl-return-from beardbolt--process-disassembled-lines
+ (when (and (> (length result) bb-binary-asm-limit)
+ (not (buffer-local-value 'bb-ignore-binary-limit
src-buffer)))
+ (cl-return-from bb--process-disassembled-lines
'("Aborting processing due to exceeding the binary limit.")))
- (when (string-match beardbolt-disass-line line)
+ (when (string-match bb-disass-line line)
;; Don't add linums from files which we aren't inspecting
;; If we get a non-absolute .file path, check to see if we
;; have a default dir. If not, treat it like we are in the
@@ -1145,46 +1147,46 @@ Argument SRC-BUFFER source buffer."
;; We are just setting a linum, no data here.
(throw 'continue t))
- (when (string-match beardbolt-disass-label line)
+ (when (string-match bb-disass-label line)
(setq func (match-string 2 line))
- (when (beardbolt--user-func-p src-buffer func)
+ (when (bb--user-func-p src-buffer func)
(push (concat func ":") result))
(throw 'continue t))
(unless (and func
- (beardbolt--user-func-p src-buffer func))
+ (bb--user-func-p src-buffer func))
(throw 'continue t))
- (when (string-match beardbolt-disass-opcode line)
+ (when (string-match bb-disass-opcode line)
(let ((line (concat (match-string 1 line)
"\t" (match-string 3 line))))
;; Add line text property if available
(when source-linum
(add-text-properties 0 (length line)
- `(beardbolt-src-line ,source-linum) line))
+ `(bb-src-line ,source-linum) line))
(push line result))
(throw 'continue t))))
(nreverse result)))
-(cl-defun beardbolt--process-src-asm-lines (src-buffer asm-lines)
- (let* ((used-labels (beardbolt--find-used-labels src-buffer asm-lines))
- (src-file-name (or (buffer-local-value 'beardbolt--real-src-file
src-buffer)
+(cl-defun bb--process-src-asm-lines (src-buffer asm-lines)
+ (let* ((used-labels (bb--find-used-labels src-buffer asm-lines))
+ (src-file-name (or (buffer-local-value 'bb--real-src-file src-buffer)
(buffer-file-name src-buffer)))
(result nil)
(prev-label nil)
(source-linum nil)
(source-file-map (make-hash-table :test #'eq))
- (def-dir (or (buffer-local-value 'beardbolt-default-directory
src-buffer)
+ (def-dir (or (buffer-local-value 'bb-default-directory src-buffer)
(and src-file-name
(file-name-directory src-file-name)))))
(dolist (line asm-lines)
- (let* ((raw-match (or (string-match beardbolt-label-def line)
- (string-match beardbolt-assignment-def line)))
+ (let* ((raw-match (or (string-match bb-label-def line)
+ (string-match bb-assignment-def line)))
(match (when raw-match
(match-string 1 line)))
(used-label-p (gethash match used-labels)))
(catch 'continue
(cond
;; Process file name hints
- ((string-match beardbolt-source-file line)
+ ((string-match bb-source-file line)
(if (match-string 3 line)
;; Clang style match
(puthash (string-to-number (match-string 1 line))
@@ -1194,7 +1196,7 @@ Argument SRC-BUFFER source buffer."
(match-string 2 line)
source-file-map)))
;; Process any line number hints
- ((string-match beardbolt-source-tag line)
+ ((string-match bb-source-tag line)
(if (or (not src-file-name) ;; Skip file match if we don't have a
current filename
;; If we get a non-absolute .file path, check to see if we
;; have a default dir. If not, treat it like we are in the
@@ -1209,7 +1211,7 @@ Argument SRC-BUFFER source buffer."
(setq source-linum (string-to-number
(match-string 2 line)))
(setq source-linum nil)))
- ((string-match beardbolt-source-stab line)
+ ((string-match bb-source-stab line)
(pcase (string-to-number (match-string 1 line))
;; http://www.math.utah.edu/docs/info/stabs_11.html
(68
@@ -1217,40 +1219,40 @@ Argument SRC-BUFFER source buffer."
((or 100 132)
(setq source-linum nil)))))
;; End block, reset prev-label and source
- (when (string-match-p beardbolt-endblock line)
+ (when (string-match-p bb-endblock line)
(setq prev-label nil))
- (when (and (buffer-local-value 'beardbolt-filter-comment-only
src-buffer)
- (string-match-p beardbolt-comment-only line))
+ (when (and (buffer-local-value 'bb-filter-comment-only src-buffer)
+ (string-match-p bb-comment-only line))
(throw 'continue t))
;; continue means we don't add to the ouptut
(when match
(if (not used-label-p)
;; Unused label
- (when (buffer-local-value 'beardbolt-filter-labels src-buffer)
+ (when (buffer-local-value 'bb-filter-labels src-buffer)
(throw 'continue t))
;; Real label, set prev-label
(setq prev-label raw-match)))
- (when (and (buffer-local-value 'beardbolt-filter-directives
src-buffer)
+ (when (and (buffer-local-value 'bb-filter-directives src-buffer)
(not match))
- (if (and (string-match-p beardbolt-data-defn line)
+ (if (and (string-match-p bb-data-defn line)
prev-label)
;; data is being used
nil
- (when (string-match-p beardbolt-directive line)
+ (when (string-match-p bb-directive line)
(throw 'continue t))))
;; Add line numbers to mapping
(when (and source-linum
- (beardbolt--has-opcode-p line))
+ (bb--has-opcode-p line))
(add-text-properties 0 (length line)
- `(beardbolt-src-line ,source-linum) line))
+ `(bb-src-line ,source-linum) line))
;; Add line
(push line result))))
(nreverse result)))
-(cl-defun beardbolt--process-php-bytecode (src-buffer asm-lines)
- (if (beardbolt--hack-p src-buffer)
+(cl-defun bb--process-php-bytecode (src-buffer asm-lines)
+ (if (bb--hack-p src-buffer)
asm-lines
(let ((state 'useless)
(current-line nil)
@@ -1266,16 +1268,16 @@ Argument SRC-BUFFER source buffer."
((string-empty-p line) (setq state 'useless))
((string-match "^ *\\([0-9]+\\) +[0-9]+" line)
(setq current-line (string-to-number (match-string 1 line)))
- (add-text-properties 0 (length line) `(beardbolt-src-line
,current-line) line))
+ (add-text-properties 0 (length line) `(bb-src-line ,current-line)
line))
(t
- (add-text-properties 0 (length line) `(beardbolt-src-line
,current-line) line)))
+ (add-text-properties 0 (length line) `(bb-src-line ,current-line)
line)))
(push line result))
(otherwise
(when (string-match "^filename:" line)
(setq state 'text)))))
(nreverse result))))
-(cl-defun beardbolt--process-python-bytecode (_src-buffer asm-lines)
+(cl-defun bb--process-python-bytecode (_src-buffer asm-lines)
(let ((source-linum nil)
(result nil))
(dolist (line asm-lines)
@@ -1302,34 +1304,34 @@ Argument SRC-BUFFER source buffer."
"\t"))
(when source-linum
(add-text-properties 0 (length line)
- `(beardbolt-src-line ,source-linum) line))
+ `(bb-src-line ,source-linum) line))
;; Add line
(push line result)))
(nreverse result)))
-(defun beardbolt--process-java-bytecode (src-buffer asm-lines)
+(defun bb--process-java-bytecode (src-buffer asm-lines)
"Wrapper for easy integration into beardbolt.
Argument SRC-BUFFER source buffer.
Argument ASM-LINES input lines."
- (beardbolt-java-process-bytecode
+ (bb-java-process-bytecode
asm-lines
- (buffer-local-value 'beardbolt-filter-directives src-buffer)))
+ (buffer-local-value 'bb-filter-directives src-buffer)))
-(cl-defun beardbolt--process-asm-lines (src-buffer asm-lines)
+(cl-defun bb--process-asm-lines (src-buffer asm-lines)
"Process and filter a set of asm lines."
(let* ((lang (with-current-buffer src-buffer
- (beardbolt--get-lang)))
+ (bb--get-lang)))
(process-asm-fn (when lang
- (beardbolt-l-process-asm-custom-fn lang))))
+ (bb-l-process-asm-custom-fn lang))))
(cond
(process-asm-fn
(funcall process-asm-fn src-buffer asm-lines))
- ((buffer-local-value 'beardbolt-disassemble src-buffer)
- (beardbolt--process-disassembled-lines src-buffer asm-lines))
+ ((buffer-local-value 'bb-disassemble src-buffer)
+ (bb--process-disassembled-lines src-buffer asm-lines))
(t
- (beardbolt--process-src-asm-lines src-buffer asm-lines)))))
+ (bb--process-src-asm-lines src-buffer asm-lines)))))
-(cl-defun beardbolt--process-go-asm-lines (_src-buffer asm-lines)
+(cl-defun bb--process-go-asm-lines (_src-buffer asm-lines)
(let ((source-linum nil)
(result nil))
(dolist (line asm-lines)
@@ -1355,12 +1357,12 @@ Argument ASM-LINES input lines."
"\t"))
(when source-linum
(add-text-properties 0 (length line)
- `(beardbolt-src-line ,source-linum) line))
+ `(bb-src-line ,source-linum) line))
;; Add line
(push line result)))
(nreverse result)))
-(defun beardbolt--rainbowize (line-mappings src-buffer)
+(defun bb--rainbowize (line-mappings src-buffer)
(let* ((background-hsl
(apply #'color-rgb-to-hsl (color-name-to-rgb (face-background
'default))))
all-ovs
@@ -1401,20 +1403,20 @@ Argument ASM-LINES input lines."
(overlay-put ov 'priority 0)))))))
line-mappings)
(with-current-buffer src-buffer
- (mapc #'delete-overlay beardbolt--rainbow-overlays)
- (setq-local beardbolt--rainbow-overlays all-ovs))))
+ (mapc #'delete-overlay bb--rainbow-overlays)
+ (setq-local bb--rainbow-overlays all-ovs))))
-(defun beardbolt--rainbowize-cleanup ()
- (mapc #'delete-overlay beardbolt--rainbow-overlays)
- (setq beardbolt--rainbow-overlays nil))
+(defun bb--rainbowize-cleanup ()
+ (mapc #'delete-overlay bb--rainbow-overlays)
+ (setq bb--rainbow-overlays nil))
;;;;; Handlers
-(cl-defun beardbolt--handle-finish-compile (buffer str &key override-buffer
stopped)
+(cl-defun bb--handle-finish-compile (buffer str &key override-buffer stopped)
"Finish hook for compilations.
Argument BUFFER compilation buffer.
Argument STR compilation finish status.
Argument OVERRIDE-BUFFER asm src buffer to use instead of reading
- `beardbolt-output-filename'.
+ `bb-output-filename'.
Argument STOPPED The compilation was stopped to start another compilation."
(when (not (buffer-live-p buffer))
(error "Dead buffer passed to compilation-finish-function! beardbolt
cannot continue."))
@@ -1422,23 +1424,23 @@ Argument STOPPED The compilation was stopped to start
another compilation."
(and str
(not (string-match "^finished" str))))
(default-directory (buffer-local-value 'default-directory buffer))
- (src-buffer (buffer-local-value 'beardbolt-src-buffer buffer)))
+ (src-buffer (buffer-local-value 'bb-src-buffer buffer)))
- (with-current-buffer (get-buffer-create beardbolt-output-buffer)
+ (with-current-buffer (get-buffer-create bb-output-buffer)
;; Store src buffer value for later linking
(cond (stopped) ; Do nothing
((not compilation-fail)
(if (and (not override-buffer)
- (not (file-exists-p (beardbolt-output-filename
src-buffer t))))
+ (not (file-exists-p (bb-output-filename src-buffer t))))
(message "Error reading from output file.")
(let ((lines
- (beardbolt--process-asm-lines
+ (bb--process-asm-lines
src-buffer
(or (when override-buffer
(with-current-buffer override-buffer
(split-string (buffer-string) "\n" nil)))
(with-temp-buffer
- (insert-file-contents (beardbolt-output-filename
src-buffer t))
+ (insert-file-contents (bb-output-filename
src-buffer t))
(split-string (buffer-string) "\n" nil)))))
(ht (make-hash-table :test #'eq))
(linum 1)
@@ -1449,7 +1451,7 @@ Argument STOPPED The compilation was stopped to start
another compilation."
(dolist (line lines)
(let ((property
(get-text-property
- 0 'beardbolt-src-line line)))
+ 0 'bb-src-line line)))
(progn
(cl-tagbody
run-conditional
@@ -1469,7 +1471,7 @@ Argument STOPPED The compilation was stopped to start
another compilation."
start-match linum))))))
(cl-incf linum))
(with-current-buffer src-buffer
- (setq beardbolt-line-mapping ht))
+ (setq bb-line-mapping ht))
;; Replace buffer contents but save point and scroll
(let* ((window (get-buffer-window output-buffer))
(old-point (window-point window))
@@ -1480,8 +1482,8 @@ Argument STOPPED The compilation was stopped to start
another compilation."
(set-window-start window old-window-start)
(set-window-point window old-point)))
(asm-mode)
- (beardbolt-mode 1)
- ;; Enrich beardbolt-line-mapping with actual position
information
+ (bb-mode 1)
+ ;; Enrich bb-line-mapping with actual position information
(maphash (lambda (_k asm-regions)
(save-excursion
(plist-put
@@ -1498,110 +1500,110 @@ Argument STOPPED The compilation was stopped to start
another compilation."
(line-end-position)))))))
ht)
- (beardbolt--rainbowize ht src-buffer)
- (setq beardbolt-src-buffer src-buffer)
+ (bb--rainbowize ht src-buffer)
+ (setq bb-src-buffer src-buffer)
(display-buffer (current-buffer) '(nil (inhibit-same-window .
t)))
- (run-at-time 0 nil #'beardbolt-update-overlays))))
+ (run-at-time 0 nil #'bb-update-overlays))))
(t ; Compilation failed
;; Display compilation buffer
(display-buffer buffer '(nil (inhibit-same-window . t)))
;; TODO find a cleaner way to disable overlays.
(with-current-buffer src-buffer
- (setq beardbolt-line-mapping nil))
- (beardbolt--remove-overlays)))
+ (setq bb-line-mapping nil))
+ (bb--remove-overlays)))
;; Reset automated recompile
- (setq beardbolt--automated-compile nil))
+ (setq bb--automated-compile nil))
;; Clear out default-set variables
(with-current-buffer src-buffer
- (dolist (var beardbolt--default-variables)
- (beardbolt--set-local var nil))
- (setq beardbolt--default-variables nil))))
+ (dolist (var bb--default-variables)
+ (bb--set-local var nil))
+ (setq bb--default-variables nil))))
;;;;; Parsing Options
-(defun beardbolt--get-lang ()
+(defun bb--get-lang ()
"Helper function to get lang def for LANGUAGE."
- (or beardbolt-language-descriptor
- (cdr-safe (assoc major-mode beardbolt-languages))))
+ (or bb-language-descriptor
+ (cdr-safe (assoc major-mode bb-languages))))
-(defun beardbolt--parse-options ()
+(defun bb--parse-options ()
"Parse RMS options from file."
(hack-local-variables)
- (let* ((lang (beardbolt--get-lang))
+ (let* ((lang (bb--get-lang))
(src-buffer (current-buffer))
- (cmd beardbolt-command)
- (dir beardbolt-default-directory)
- (force-disass (not (beardbolt-l-supports-asm lang)))
- (force-asm (not (beardbolt-l-supports-disass lang))))
+ (cmd bb-command)
+ (dir bb-default-directory)
+ (force-disass (not (bb-l-supports-asm lang)))
+ (force-asm (not (bb-l-supports-disass lang))))
;; If this is non-nil, most likely we are running two compiles at once.
;; This is not exactly ideal, as it causes a race condition.
- (when beardbolt--default-variables
+ (when bb--default-variables
(message "It looks like beardbolt state wasn't cleaned up properly.
Are you running two compilations at the same time?"))
(when (and force-disass force-asm)
(error "No disassemble method found for this langauge, please double
check spec"))
(when force-disass
- (setq-local beardbolt-disassemble t))
+ (setq-local bb-disassemble t))
(when force-asm
- (setq-local beardbolt-disassemble nil))
+ (setq-local bb-disassemble nil))
(when (not dir)
- (add-to-list 'beardbolt--default-variables 'beardbolt-default-directory)
- (setq-local beardbolt-default-directory
- (let ((new-dir (beardbolt-l-default-directory lang)))
+ (add-to-list 'bb--default-variables 'bb-default-directory)
+ (setq-local bb-default-directory
+ (let ((new-dir (bb-l-default-directory lang)))
(pcase new-dir
((pred functionp) (funcall new-dir src-buffer))
(_ new-dir)))))
(when (not cmd)
- (add-to-list 'beardbolt--default-variables 'beardbolt-command)
- (setq-local beardbolt-command
- (let ((new-cmd (beardbolt-l-compile-cmd lang)))
+ (add-to-list 'bb--default-variables 'bb-command)
+ (setq-local bb-command
+ (let ((new-cmd (bb-l-compile-cmd lang)))
(pcase new-cmd
((pred functionp) (funcall new-cmd src-buffer))
(_ new-cmd)))))
src-buffer))
-(defun beardbolt--demangle-command (existing-cmd lang src-buffer)
+(defun bb--demangle-command (existing-cmd lang src-buffer)
"Append a demangler routine to EXISTING-CMD with LANG and SRC-BUFFER
and return it."
- (if-let ((to-demangle (buffer-local-value 'beardbolt-demangle src-buffer))
- (demangler (beardbolt-l-demangler lang))
+ (if-let ((to-demangle (buffer-local-value 'bb-demangle src-buffer))
+ (demangler (bb-l-demangler lang))
(demangler-exists (executable-find demangler)))
(concat existing-cmd " "
(mapconcat
#'identity
(list "&&" demangler
- "<" (beardbolt-output-filename src-buffer t)
- ">" (expand-file-name "tmp.s" beardbolt--temp-dir)
+ "<" (bb-output-filename src-buffer t)
+ ">" (expand-file-name "tmp.s" bb--temp-dir)
"&&" "mv"
- (expand-file-name "tmp.s" beardbolt--temp-dir)
- (beardbolt-output-filename src-buffer t))
+ (expand-file-name "tmp.s" bb--temp-dir)
+ (bb-output-filename src-buffer t))
" "))
existing-cmd))
;;;;; UI Functions
-(defun beardbolt-compile ()
+(defun bb-compile ()
"Compile the current beardbolt buffer."
(interactive)
(when (and (buffer-modified-p)
(yes-or-no-p (format "Save buffer %s? " (buffer-name))))
(save-buffer))
- (beardbolt--gen-temp)
+ (bb--gen-temp)
;; Current buffer = src-buffer at this point
- (setq beardbolt-src-buffer (current-buffer))
+ (setq bb-src-buffer (current-buffer))
(cond
((eq major-mode 'asm-mode)
;; We cannot compile asm-mode files
(message "Cannot compile assembly files. Are you sure you are not in the
output buffer?"))
- ((beardbolt-l-elisp-compile-override (beardbolt--get-lang))
+ ((bb-l-elisp-compile-override (bb--get-lang))
(with-current-buffer (or (buffer-base-buffer) (current-buffer))
(funcall
- (beardbolt-l-elisp-compile-override (beardbolt--get-lang))
+ (bb-l-elisp-compile-override (bb--get-lang))
:src-buffer (current-buffer))))
(t
- (beardbolt--stop-running-compilation)
- (beardbolt--parse-options)
+ (bb--stop-running-compilation)
+ (bb--parse-options)
(let* ((src-buffer (current-buffer))
- (lang (beardbolt--get-lang))
- (func (beardbolt-l-compile-cmd-function lang))
+ (lang (bb--get-lang))
+ (func (bb-l-compile-cmd-function lang))
;; Generate command
(cmd
;; Compilation commands assume the current buffer is a real file
@@ -1609,24 +1611,24 @@ and return it."
(with-current-buffer (or (buffer-base-buffer) (current-buffer))
(funcall func :src-buffer src-buffer)))
(asm-format
- (buffer-local-value 'beardbolt-asm-format src-buffer))
- (default-directory (or beardbolt-default-directory
- beardbolt--temp-dir)))
- (run-hooks 'beardbolt-after-parse-hook)
- (beardbolt--rainbowize-cleanup)
- (when (buffer-local-value 'beardbolt-disassemble src-buffer)
+ (buffer-local-value 'bb-asm-format src-buffer))
+ (default-directory (or bb-default-directory
+ bb--temp-dir)))
+ (run-hooks 'bb-after-parse-hook)
+ (bb--rainbowize-cleanup)
+ (when (buffer-local-value 'bb-disassemble src-buffer)
(pcase
- (beardbolt-l-objdumper lang)
+ (bb-l-objdumper lang)
('objdump
(setq cmd
(mapconcat #'identity
(list cmd
"&&"
- beardbolt-objdump-binary "-d"
(beardbolt-output-filename src-buffer)
+ bb-objdump-binary "-d" (bb-output-filename
src-buffer)
"-C" "--insn-width=16" "-l"
(when (not (booleanp asm-format))
(concat "-M " asm-format))
- ">" (beardbolt-output-filename src-buffer t))
+ ">" (bb-output-filename src-buffer t))
" ")))
('go-objdump
(setq cmd
@@ -1634,74 +1636,74 @@ and return it."
(list cmd
"&&"
"go" "tool"
- "objdump" (beardbolt-output-filename
src-buffer)
- ">" (beardbolt-output-filename src-buffer t))
+ "objdump" (bb-output-filename src-buffer)
+ ">" (bb-output-filename src-buffer t))
" ")))
('cat
(setq cmd
(mapconcat #'identity
(list cmd
"&&" "mv"
- (beardbolt-output-filename src-buffer)
- (beardbolt-output-filename src-buffer t))
+ (bb-output-filename src-buffer)
+ (bb-output-filename src-buffer t))
" ")))
(_
(error "Objdumper not recognized"))))
;; Convert to demangle if we need to
- (setq cmd (beardbolt--demangle-command cmd lang src-buffer))
+ (setq cmd (bb--demangle-command cmd lang src-buffer))
(with-current-buffer ; With compilation buffer
- (let ((shell-file-name (or (executable-find beardbolt--shell)
+ (let ((shell-file-name (or (executable-find bb--shell)
shell-file-name))
(compilation-auto-jump-to-first-error t))
;; TODO should this be configurable?
- (beardbolt-with-display-buffer-no-window
- (compilation-start cmd nil (lambda (&rest _)
"*beardbolt-compilation*"))))
+ (bb-with-display-buffer-no-window
+ (compilation-start cmd nil (lambda (&rest _)
"*bb-compilation*"))))
;; Only jump to errors, skip over warnings
(setq-local compilation-skip-threshold 2)
(add-hook 'compilation-finish-functions
- #'beardbolt--handle-finish-compile nil t)
- (setq beardbolt-src-buffer src-buffer))))))
+ #'bb--handle-finish-compile nil t)
+ (setq bb-src-buffer src-buffer))))))
-(defun beardbolt--stop-running-compilation ()
- (when-let* ((compilation-buffer (get-buffer "*beardbolt-compilation*"))
+(defun bb--stop-running-compilation ()
+ (when-let* ((compilation-buffer (get-buffer "*bb-compilation*"))
(proc (get-buffer-process compilation-buffer)))
(when (eq (process-status proc) 'run)
(set-process-sentinel proc nil)
(interrupt-process proc)
- (beardbolt--handle-finish-compile compilation-buffer nil :stopped t)
+ (bb--handle-finish-compile compilation-buffer nil :stopped t)
;; Wait a short while for the process to exit cleanly
(sit-for 0.2)
(delete-process proc))))
;;;; Keymap
-(defvar beardbolt-mode-map
+(defvar bb-mode-map
(let ((map (make-sparse-keymap)))
- (define-key map (kbd "C-c C-c") #'beardbolt-compile)
+ (define-key map (kbd "C-c C-c") #'bb-compile)
map)
- "Keymap for function `beardbolt-mode'.")
+ "Keymap for function `bb-mode'.")
;;;; Init commands
-(defun beardbolt--gen-temp ()
+(defun bb--gen-temp ()
"Generate beardbolt temp dir if needed."
- (unless (and beardbolt--temp-dir
- (file-exists-p beardbolt--temp-dir))
- (setq beardbolt--temp-dir
- (make-temp-file "beardbolt-" t))
+ (unless (and bb--temp-dir
+ (file-exists-p bb--temp-dir))
+ (setq bb--temp-dir
+ (make-temp-file "bb-" t))
(add-hook 'kill-emacs-hook
(lambda ()
- (when (and (boundp 'beardbolt--temp-dir)
- beardbolt--temp-dir
- (file-directory-p beardbolt--temp-dir))
- (delete-directory beardbolt--temp-dir t))
- (setq beardbolt--temp-dir nil)))))
+ (when (and (boundp 'bb--temp-dir)
+ bb--temp-dir
+ (file-directory-p bb--temp-dir))
+ (delete-directory bb--temp-dir t))
+ (setq bb--temp-dir nil)))))
;;;;; Starter Definitions
;; IIUC, this "starter" business is not a necessary part of beardbolt, but is
;; a way to provide sample files with which users can try out beardbolt.
-(defvar beardbolt-starter-files
+(defvar bb-starter-files
'(("c" . "beardbolt.c")
("c++" . "beardbolt.cpp")
("ocaml" . "beardbolt.ml")
@@ -1711,7 +1713,7 @@ and return it."
("haskell" . "beardbolt.hs")
("php" . "beardbolt.php")
("pony" . "beardbolt.pony")
- ("emacs-lisp" . "beardbolt-starter.el")
+ ("emacs-lisp" . "bb-starter.el")
("d" . "beardbolt.d")
("zig" . "beardbolt.zig")
("go" . "beardbolt.go")
@@ -1721,42 +1723,42 @@ and return it."
("java" . "beardbolt.java")))
;;;###autoload
-(defun beardbolt-starter (lang-name)
+(defun bb-starter (lang-name)
"Setup new file based on the sample STARTER-FILE-NAME."
(interactive
- (list (completing-read "Language: " beardbolt-starter-files nil t)))
- (beardbolt--gen-temp)
- (let* ((starter-file-name (cdr (assoc lang-name beardbolt-starter-files)))
+ (list (completing-read "Language: " bb-starter-files nil t)))
+ (bb--gen-temp)
+ (let* ((starter-file-name (cdr (assoc lang-name bb-starter-files)))
(file-name
- (expand-file-name starter-file-name beardbolt--temp-dir))
+ (expand-file-name starter-file-name bb--temp-dir))
(exists (file-exists-p file-name))
(src-file-name
- (when beardbolt-dir
+ (when bb-dir
(expand-file-name starter-file-name
- (expand-file-name "starters/" beardbolt-dir))))
+ (expand-file-name "starters/" bb-dir))))
(src-file-exists (when src-file-name
(file-exists-p src-file-name))))
(if (not src-file-exists)
- (error "Could not find starter files! Are you sure the starter/ folder
is available? If you want to overide, set `beardbolt-dir' to your install path")
+ (error "Could not find starter files! Are you sure the starter/ folder
is available? If you want to overide, set `bb-dir' to your install path")
(unless exists
(copy-file src-file-name file-name))
(find-file file-name)
- (unless beardbolt-mode
- (beardbolt-mode 1)))))
+ (unless bb-mode
+ (bb-mode 1)))))
;;;; Overlay Commands
-(defun beardbolt--goto-line (line)
+(defun bb--goto-line (line)
"Goto a certain LINE."
(when line
(let ((cur (line-number-at-pos)))
(forward-line (- line cur)))))
-(defun beardbolt--setup-overlay (start end buf)
+(defun bb--setup-overlay (start end buf)
"Setup overlay with START and END in BUF."
(let ((o (make-overlay start end buf)))
- (overlay-put o 'face 'beardbolt-current-line-face)
+ (overlay-put o 'face 'bb-current-line-face)
(overlay-put o 'priority 1)
o))
-(cl-defun beardbolt--point-visible (point)
+(cl-defun bb--point-visible (point)
"Check if the current point is visible in a window in the current buffer."
(when (cl-find-if (lambda (w)
(and (>= point (window-start w))
@@ -1764,26 +1766,26 @@ and return it."
(get-buffer-window-list))
t))
-(cl-defun beardbolt-update-overlays (&key (force nil))
+(cl-defun bb-update-overlays (&key (force nil))
"Update overlays to highlight the currently selected source and asm lines.
If FORCE, always scroll overlay, even when one is visible.
FORCE also scrolls to the first line, instead of the first line
of the last block."
- (when beardbolt-mode
- (if-let ((should-run beardbolt-use-overlays)
- (output-buffer (get-buffer beardbolt-output-buffer))
- (src-buffer (buffer-local-value 'beardbolt-src-buffer
output-buffer))
+ (when bb-mode
+ (if-let ((should-run bb-use-overlays)
+ (output-buffer (get-buffer bb-output-buffer))
+ (src-buffer (buffer-local-value 'bb-src-buffer output-buffer))
(should-run (and (or (eq (current-buffer) src-buffer)
(eq (current-buffer) output-buffer))
;; Don't run on unsaved buffers
(not (buffer-modified-p src-buffer))
- (buffer-local-value 'beardbolt-mode src-buffer)))
+ (buffer-local-value 'bb-mode src-buffer)))
(current-line (line-number-at-pos))
(src-current-line
(if (eq (current-buffer) src-buffer)
current-line
- (get-text-property (point) 'beardbolt-src-line)))
- (line-mappings (buffer-local-value 'beardbolt-line-mapping
src-buffer))
+ (get-text-property (point) 'bb-src-line)))
+ (line-mappings (buffer-local-value 'bb-line-mapping src-buffer))
(asm-region-plist (gethash src-current-line line-mappings))
(asm-region-lines (plist-get asm-region-plist :lines))
(asm-region-positions (plist-get asm-region-plist :positions))
@@ -1791,23 +1793,23 @@ and return it."
(src-pts
(with-current-buffer src-buffer
(save-excursion
- (beardbolt--goto-line src-current-line)
+ (bb--goto-line src-current-line)
(cl-values (c-point 'bol) (c-point 'bonl))))))
(let*
;; If nil, output-buffer is scrolled instead
((scroll-src-buffer-p (not (eq (current-buffer) src-buffer)))
- (line-visible (or (not beardbolt-goto-match)
+ (line-visible (or (not bb-goto-match)
(when scroll-src-buffer-p
(with-current-buffer src-buffer
- (beardbolt--point-visible (cl-first
src-pts)))))))
+ (bb--point-visible (cl-first src-pts)))))))
;; Remove existing overlays
- (beardbolt--remove-overlays)
- (push (beardbolt--setup-overlay (cl-first src-pts) (cl-second
src-pts) src-buffer)
- beardbolt-overlays)
+ (bb--remove-overlays)
+ (push (bb--setup-overlay (cl-first src-pts) (cl-second src-pts)
src-buffer)
+ bb-overlays)
(with-current-buffer output-buffer
(cl-loop for (start . end) in asm-region-positions
- do (push (beardbolt--setup-overlay start end
output-buffer)
- beardbolt-overlays))
+ do (push (bb--setup-overlay start end output-buffer)
+ bb-overlays))
(when (or (not line-visible) force)
;; Scroll buffer to first line
(when-let ((scroll-buffer (if scroll-src-buffer-p
@@ -1822,62 +1824,62 @@ and return it."
(car (last asm-region-lines))
(cl-first asm-region-lines))))))
(with-selected-window window
- (beardbolt--goto-line line-scroll)
+ (bb--goto-line line-scroll)
;; If we scrolled, recenter
(recenter))))))
- (beardbolt--remove-overlays))
- ;; If not in beardbolt-mode, don't do anything
+ (bb--remove-overlays))
+ ;; If not in bb-mode, don't do anything
))
-(defun beardbolt--remove-overlays ()
+(defun bb--remove-overlays ()
"Clean up overlays, assuming they are no longer needed."
- (mapc #'delete-overlay beardbolt-overlays)
- (setq beardbolt-overlays nil))
+ (mapc #'delete-overlay bb-overlays)
+ (setq bb-overlays nil))
-(defun beardbolt--post-command-hook ()
+(defun bb--post-command-hook ()
;; Use (point) instead of (line-number-at-pos) to track movements because
;; the former is faster (constant runtime)
- (unless (eq (point) beardbolt--last-point)
- (setq beardbolt--last-point (point))
- (beardbolt-update-overlays)))
+ (unless (eq (point) bb--last-point)
+ (setq bb--last-point (point))
+ (bb-update-overlays)))
-(defun beardbolt--on-kill-buffer ()
- (when-let (output-buffer (get-buffer beardbolt-output-buffer))
+(defun bb--on-kill-buffer ()
+ (when-let (output-buffer (get-buffer bb-output-buffer))
(when (or (eq (current-buffer) output-buffer)
- (eq (current-buffer) (buffer-local-value 'beardbolt-src-buffer
output-buffer)))
- (beardbolt--remove-overlays))))
-
-(defun beardbolt--is-active-src-buffer ()
- (when-let (output-buffer (get-buffer beardbolt-output-buffer))
- (eq (current-buffer) (buffer-local-value 'beardbolt-src-buffer
output-buffer))))
-
-(defun beardbolt--after-save ()
- (when (and (beardbolt--is-active-src-buffer)
- beardbolt-automatic-recompile)
- (setq beardbolt--automated-compile t)
- (beardbolt-compile)))
-
-;; Auto-save the src buffer after it has been unchanged for
`beardbolt-compile-delay' seconds.
-;; The buffer is then automatically recompiled via `beardbolt--after-save'.
-(defvar beardbolt--change-timer nil)
-(defvar beardbolt--buffer-to-auto-save nil)
-
-(defun beardbolt--after-change (&rest _)
- (when (and (beardbolt--is-active-src-buffer)
- beardbolt-automatic-recompile
- (not (eq beardbolt-automatic-recompile 'on-save)))
- (when beardbolt--change-timer
- (cancel-timer beardbolt--change-timer))
- (setq beardbolt--buffer-to-auto-save (current-buffer)
- beardbolt--change-timer (run-with-timer beardbolt-compile-delay nil
#'beardbolt--on-change-timer))))
-
-(defun beardbolt--on-change-timer ()
- (setq beardbolt--change-timer nil)
- (when (buffer-live-p beardbolt--buffer-to-auto-save)
- (with-current-buffer beardbolt--buffer-to-auto-save
- (setq beardbolt--buffer-to-auto-save nil)
- (when (or (< (line-number-at-pos (point-max))
beardbolt-large-buffer-size)
- (eq beardbolt-automatic-recompile 'force))
+ (eq (current-buffer) (buffer-local-value 'bb-src-buffer
output-buffer)))
+ (bb--remove-overlays))))
+
+(defun bb--is-active-src-buffer ()
+ (when-let (output-buffer (get-buffer bb-output-buffer))
+ (eq (current-buffer) (buffer-local-value 'bb-src-buffer output-buffer))))
+
+(defun bb--after-save ()
+ (when (and (bb--is-active-src-buffer)
+ bb-automatic-recompile)
+ (setq bb--automated-compile t)
+ (bb-compile)))
+
+;; Auto-save the src buffer after it has been unchanged for `bb-compile-delay'
seconds.
+;; The buffer is then automatically recompiled via `bb--after-save'.
+(defvar bb--change-timer nil)
+(defvar bb--buffer-to-auto-save nil)
+
+(defun bb--after-change (&rest _)
+ (when (and (bb--is-active-src-buffer)
+ bb-automatic-recompile
+ (not (eq bb-automatic-recompile 'on-save)))
+ (when bb--change-timer
+ (cancel-timer bb--change-timer))
+ (setq bb--buffer-to-auto-save (current-buffer)
+ bb--change-timer (run-with-timer bb-compile-delay nil
#'bb--on-change-timer))))
+
+(defun bb--on-change-timer ()
+ (setq bb--change-timer nil)
+ (when (buffer-live-p bb--buffer-to-auto-save)
+ (with-current-buffer bb--buffer-to-auto-save
+ (setq bb--buffer-to-auto-save nil)
+ (when (or (< (line-number-at-pos (point-max)) bb-large-buffer-size)
+ (eq bb-automatic-recompile 'force))
;; Clear `before-save-hook' to prevent things like whitespace cleanup
;; (e.g., set by spacemacs in `spacemacs-whitespace-cleanup.el`)
;; and aggressive indenting from running (this is a hot recompile).
@@ -1889,44 +1891,47 @@ and return it."
;;;###autoload
;; TODO handle more modes than c-mode
-(define-minor-mode beardbolt-mode
- "Toggle beardbolt-mode.
+(define-minor-mode bb-mode
+ "Toggle bb-mode.
This mode is enabled in both src and assembly output buffers."
:global nil
- :lighter beardbolt-mode-lighter
- :keymap beardbolt-mode-map
+ :lighter bb-mode-lighter
+ :keymap bb-mode-map
;; Init
(cond
- (beardbolt-mode
- (setq beardbolt--last-point (point))
- (add-hook 'post-command-hook #'beardbolt--post-command-hook nil t)
- (add-hook 'kill-buffer-hook #'beardbolt--on-kill-buffer nil t)
+ (bb-mode
+ (setq bb--last-point (point))
+ (add-hook 'post-command-hook #'bb--post-command-hook nil t)
+ (add-hook 'kill-buffer-hook #'bb--on-kill-buffer nil t)
- (when (and beardbolt-automatic-recompile
+ (when (and bb-automatic-recompile
;; Only turn on auto-save in src buffers
- (not (eq (current-buffer) (get-buffer
beardbolt-output-buffer))))
- (add-hook 'after-save-hook #'beardbolt--after-save nil t)
- (when (eq beardbolt-automatic-recompile t)
- (add-hook 'after-change-functions #'beardbolt--after-change nil t)))
+ (not (eq (current-buffer) (get-buffer bb-output-buffer))))
+ (add-hook 'after-save-hook #'bb--after-save nil t)
+ (when (eq bb-automatic-recompile t)
+ (add-hook 'after-change-functions #'bb--after-change nil t)))
- (beardbolt--gen-temp))
+ (bb--gen-temp))
(t ;; Cleanup
- (beardbolt--remove-overlays)
- (remove-hook 'after-change-functions #'beardbolt--after-change t)
- (remove-hook 'after-save-hook #'beardbolt--after-save t)
- (remove-hook 'kill-buffer-hook #'beardbolt--on-kill-buffer t)
- (remove-hook 'post-command-hook #'beardbolt--post-command-hook t))))
+ (bb--remove-overlays)
+ (remove-hook 'after-change-functions #'bb--after-change t)
+ (remove-hook 'after-save-hook #'bb--after-save t)
+ (remove-hook 'kill-buffer-hook #'bb--on-kill-buffer t)
+ (remove-hook 'post-command-hook #'bb--post-command-hook t))))
;;;###autoload
(defun beardbolt ()
- "Start a beardbolt compilation and enable `beardbolt-mode' for code region
+ "Start a beardbolt compilation and enable `bb-mode' for code region
highlighting and automatic recompilation."
(interactive)
- (unless beardbolt-mode
- (beardbolt-mode))
- (beardbolt-compile))
+ (unless bb-mode
+ (bb-mode))
+ (bb-compile))
(provide 'beardbolt)
;;; beardbolt.el ends here
+;; Local Variables:
+;; read-symbol-shorthands: (("bb-" . "beardbolt-"))
+;; End:
- [elpa] externals/beardbolt 28ccabf318 190/323: Clean up overlays and simplify hook when asm buffer is closed, (continued)
- [elpa] externals/beardbolt 28ccabf318 190/323: Clean up overlays and simplify hook when asm buffer is closed, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 3a8964d537 204/323: Update Readme, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 7c81d55d3e 202/323: Format go block, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 9b1a5abbdf 208/323: Strip -flto flag from compile_commands.json by default, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt d257e51fce 244/323: starters/zig: Automatically export functions, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt ebbdebc66f 239/323: Improve compilation buffer display UX, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt f6b72fe0eb 248/323: First stab at rainbow overlays, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 3cace942b8 251/323: Fix buffer selection problems, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 041234b499 241/323: Improve auto-compilation, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 2421b29094 255/323: Remove .ert-runner, .gitlab-ci.yml and Cask, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 49e2500be1 259/323: Use shorthands so I can just type bb- instead of beardbolt-,
ELPA Syncer <=
- [elpa] externals/beardbolt 58b07a215c 268/323: Simplify some code, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 9f6d1cf10c 269/323: Remove some rmsbolt remnants, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 5deed3972e 276/323: * beardbolt.el (bb--reachable-p, bb--process-asm): Use obarrays., ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 291f82a324 266/323: Continue rewriting, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 3195997ccd 275/323: * beardbolt.el (bb--synch-relation-overlays): Rework and bugfix., ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt a13f8fe7f4 287/323: Reset beardbolt-specific locals before hacking them in, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 85d24d69f1 286/323: Add bb-kill-symbol-re option, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 10fe7307c3 291/323: Get a better C++ starter example, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 5324775417 321/323: Add beardbolt-shuffle-rainbow option, ELPA Syncer, 2023/03/09
- [elpa] externals/beardbolt 90b5cad9c1 016/323: Finish initial implementation of dissasembly, ELPA Syncer, 2023/03/09