GithubHelp home page GithubHelp logo

aartaka / graven-image Goto Github PK

View Code? Open in Web Editor NEW
19.0 4.0 3.0 420 KB

Portability library for better interaction and debugging of a running Common Lisp image through text REPL.

License: BSD 3-Clause "New" or "Revised" License

Common Lisp 93.45% Scheme 1.67% NewLisp 4.88%
benchmarking debugging garbage-collection help inspection lisp memory reflection common-lisp

graven-image's Introduction

Artyom Bologov, an interface junkie

Hey there! Name’s Artyom, and I’m a

  • Nested
    • lists
      • lover.
  • Certified yak shaver:
  • Simple and semantic web design enjoyer.
  • Programmer, hacker-poet, writer, programming language and compiler junkie.
    • Example projects:
    • Dream projects (i.e. projects I’d love to do but need more knowledge/courage/money to start):
      • an infinitely extensible PDP-8 assembly-like language with Lisp-inspired code-optimizing macros.
  • Interface-addicted:
    • mostly muscle memory of Emacs,
    • but also Magit/PureData knowledge domain representation appreciation.
    • Example projects:
      • Nyxt as a test bed for all kinds of Design Systems, Malleable Software, and Power-User Design experiments;
      • Graven Image as an attempt to make running Lisp image more inspectable.
      • cl-pure-data as an attempt to bring/bridge the graphicality of PureData back to the textual coding.
    • Dream projects:
      • structural code editor for touchscreens, resembling /Hacked/ (the Android game),
      • no-screen physical interface Fidget Cube computer, reliant on semantic info extraction from the Web, screen-reader/audio-interfaces research, and pleasant tactile feedback.
  • (Privacy-|Eco-|FOSS-) activist. Ethnically Russian. Struggling with the collective guilt for the war Putin started on 2022 Feb 24th. Envying the post-Soviet countries that have gotten to their political sustainability, hoping for the success of the remaining countries escaping the Communist/Imperialist/Colonial past (Россия Будет Свободной! Слава Україні! Жыве Беларусь!).
    • Dream projects:
      • decentralized/federated (ActivityPub-based?) chat with every message only available to a certain group of people and thus deprecating the concept of chats in favor of direct cocktail-party style communication;
      • fully anonymous plain text chat with no way to trace one’s identity (at all).

graven-image's People

Contributors

aartaka avatar fstamour avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar

graven-image's Issues

More recreatable field names in FIELDS*

What would be good for recursive and reproducible describe*/inspect* workflow is using the function that represents the field as the field name. E.g., use find-class instead of class-binding in (describe* 'nyxt:buffer):

From:
CLASS-BINDING     = #<NYXT:USER-CLASS NYXT:BUFFER>
To:
CL:FIND-CLASS     = #<NYXT:USER-CLASS NYXT:BUFFER>

Originally posted by @aartaka in #22 (comment)

Implementation support: CCL

  • Y-OR-N-P*, YES-OR-NO-P*
    • Ensure that I/O (FINISH-OUTPUT etc.) is not buggy.
  • APROPOS*, APROPOS-LIST*
    • Make sure that Graven Image APROPOS-LIST* returns the same
      data as the standard APROPOS-LIST when used with standard params.
      • (set-difference (apropos-list "A") (graven-image:apropos-list* "A"))
  • FUNCTION-LAMBDA-EXPRESSION* etc.
    • Name fetching.
    • Arglist fetching.
    • Closure fetching.
    • Ftype fetching.
    • Source search.
    • Source parsing.
    • Generic functions support.
      • Methods support.
  • TIME*
    • Real time.
    • User run time.
    • System run time.
    • CPU cores utilized.
    • CPU cycles spent.
    • CPU load.
    • GC count.
    • GC time.
    • Bytes consed.
    • Whether the evaluation aborted.
    • Page faults.
  • DESCRIBE*, INSPECT*
    • Object IDs.
    • Object/type system specifics.
    • Implementation-specific properties.
    • Implementation-specific types/objects:
      • ccl:uvector-inspector
    • MOP object inspection.
    • Proper function/funcallable hierarchy inspection.
  • DRIBBLE*
    • Trivial Gray Streams support.
    • Error output.
    • REPL prompt cleanup.
    • Empty line stripping.
  • ED*
    • Function s-expr editing.
      • Persisting the edited code into the function itself (compilation).
    • File editing.
      • Big files fetching.
      • Binary files.
      • Lisp files.
      • Plaintext files.
    • String editing.
      • Modifying the string in memory.
  • INVOKE-DEBUGGER*
    • Overriding the implementation-specific debugger.
    • Running standard debugger hooks unobtrusively.
    • Listing restarts.
    • Backtrace inspection (dissect).
      • Functions name.
      • Arguments.
      • Locals.
      • Eval-in-frame.

Needed to depend-on sb-introspect for sbcl

I needed to add the following for this to load into sbcl:

diff --git a/graven-image.asd b/graven-image.asd
index eef5627..23c0a60 100644
--- a/graven-image.asd
+++ b/graven-image.asd
@@ -11,7 +11,7 @@
   :version "0.0.1"
   :serial t
   :pathname "source/"
-  :depends-on ("closer-mop" "trivial-gray-streams")
+  :depends-on ("closer-mop" "trivial-gray-streams" #+sbcl "sb-introspect")
   :components ((:file "package")
                (:file "graven-image")
                (:file "function-lambda-expression")

De-abstactify INSPECT* and remove DEFINTERFACE?

definterface was a premature optimization. Inspector is restricted by this abstraction, and this abstraction is not really universal due to being inspector-specific. It will help to make inspect* even more fine-grained without restricting it to a supposed reuse (in ed*?).

Bad Feature Flag Usage in ASD

https://github.com/aartaka/graven-image/blob/cc47baf21d639dadc7b4226a8f1d3498b206c094/graven-image.asd#L14C1-L14C1

Note that you should not use feature flags anywhere within an ASD as it hinders introspection through ASDF. Further, sb-introspect is not a system, but rather a module, so it should be depended on differently. The correct way to do this is to use (:feature :sbcl (:require :sb-introspect)).

Fwiw for feature-conditionalising components within the system, you should use the syntax (:file "foo" :if-feature :bla)

TRACE*

Function specs:

  • Function.
  • Setf function.
  • Method.
  • Compiler macro.
  • Labels/flet.
  • Package string.

SBCL options:

  • :report
  • :condition, :condition-after, :condition-all
  • :break, :break-after, :break-all
  • :print, :print-after, :print-all
  • :wherein
  • :encapsulate
  • :methods
  • :function

CCL options:

  • :before
  • :after
  • :methods
  • :if, :condition, :before-if, :if-before, :after-if, :if-after
  • :print, :print-before, :print-after
  • :eval, :eval-before, :eval-after
  • :break, :break-before, :break-after
  • :backtrace, :backtrace-before, :backtrace-after
  • :inside, :wherein
  • :define-if-not

ECL options:

  • :break, :break-after
  • :cond, :cond-before, :cond-after
  • :print, :print-after
  • :step

CLISP options:

  • :suppress-if
  • :max-depth
  • :step-if
  • :bindings
  • :pre, :post
  • :pre-break-if, :post-break-if
  • :pre-print, :post-print, :print

ABCL options:

  • :break

Alegro options:

  • :condition
  • :break-before
  • :break-after
  • :break-all
  • :inside
  • :not-inside
  • :print-before
  • :print-after
  • :print-all
  • :show-stack

Option-local inspection:

  • Function arguments.
  • Function locals?
  • Function values?

Control variables:

  • Maximum depth.
  • Current trace depth.

Implementation support: SBCL

  • Y-OR-N-P*, YES-OR-NO-P*
    • Ensure that I/O (FINISH-OUTPUT etc.) is not buggy.
  • APROPOS*, APROPOS-LIST*
    • Make sure that Graven Image APROPOS-LIST* returns the same
      data as the standard APROPOS-LIST when used with standard params.
  • FUNCTION-LAMBDA-EXPRESSION* etc.
    • Name fetching.
    • Arglist fetching.
    • Closure fetching.
    • Ftype fetching.
    • Source search.
    • Source parsing.
    • Generic functions support.
      • Methods support.
    • FORCE.
  • TIME*
    • Real time.
    • User run time.
    • System run time.
    • CPU cores utilized.
    • CPU cycles spent.
    • CPU load.
    • GC count.
    • GC time.
    • Bytes consed.
    • Whether the evaluation aborted.
    • Page faults.
  • DESCRIBE*, INSPECT*
    • Object IDs.
    • Object/type system specifics.
    • Implementation-specific properties.
    • Implementation-specific types/objects:
      • sb-kernel:code-component
      • sb-ext:weak-pointer
      • sb-kernel:fdefn
    • MOP object inspection.
    • Proper function/funcallable hierarchy inspection.
  • DRIBBLE*
    • Trivial Gray Streams support.
    • Error output.
    • REPL prompt cleanup.
    • Empty line stripping.
  • ED*
    • Function s-expr editing.
      • Persisting the edited code into the function itself (compilation).
    • File editing.
      • Big files fetching.
      • Binary files.
      • Lisp files.
      • Plaintext files.
    • String editing.
      • Modifying the string in memory.
  • INVOKE-DEBUGGER*
    • Overriding the implementation-specific debugger.
    • Running standard debugger hooks unobtrusively.
    • Listing restarts.
    • Backtrace inspection (dissect).
      • Functions name.
      • Arguments.
      • Locals.
      • Eval-in-frame.

FUNCTION-LAMBDA-EXPRESSION* completeness

  • Closure inspection
    • ECL
    • Allegro
      • sys::augmentable-environment
      • #<Closure DEFSTRUCT-ACCESSOR @ #x10000237d42>
    • CLASP
    • CLISP
    • Lispworks
    • Corman
    • MKCL
  • Source expression
    • ABCL
      • Sources for Lisp objects.
      • Sources for Java-related objects.
    • Allegro
    • CLASP
    • CLISP
    • Lispworks
    • Corman
    • CMUCL, SCL
    • MKCL
  • Function type
    • CCL—ftype declarations
    • ABCL—impossible, it's all LispObject possible via ftype declarations.
    • Allegro—ftype too (huh, that's an easy technique, might be possible to propagate to all the implementations that don't expose real compiled types 🤔)
    • CLASP
    • CLISP
    • Lispworks
    • Corman
    • MKCL
  • Funcallable instance
  • Macro functions
    • SBCL lists the right arglist for macros, but CCL, ECL, ABCL etc. list something like (#:WHOLE-182692 #:ENVIRONMENT-182693), which is macro function arglist, not macro arglist.

Split into core and interactive systems

Now that I've made Trivial Toplevel Commands, the model of "always in debugger/inspector" that Allegro employs is quite tempting. Given this, custom command processors that Graven Image defines feel like a bleak parody of the real implementation REPLs. Might be useful to rewrite it with actual REPL commands.

But, to make that possible, Graven Image has to either:

  • Split into two separate systems:
    • graven-image/core with things like function-lambda-expresion* and fields*,
    • and graven-image/interactive (or /interface) for interactive functions like inspect*.
  • Or at least not redefine/pretend to be standard functions.
    • Which is almost the same as doing nothing, because this "Graven Image + Commands" library will probably use a different naming convention or no naming convention altogether, only relying on commands?

Still, won't hurt to split the library into two separate components so that using core doesn't come with using opinionated (even if modeled after implementation-specific) inspect* etc.

This is not much of a problem, but it will become one when there's more interactive functions: ed*, step*, whatever.

BREAK* completeness

  • Current frame/function fetching:
    • ECL
    • ABCL
    • Allegro
    • CLASP
    • Lispworks
    • Corman
    • CMUCL, SCL
    • MKCL
  • Arglist listing?
  • Indentation? Prettier variable listing?
  • Customizable formatter.
  • Maybe introduce a with-break* macro? Potential behavior:
(with-break*
  (+ 1 2 most-positive-fixnum))
;; (progn
;;   (break* "Before evaluating ~s" '(+ 1 2 most-positive-fixnum))
;;   (let ((args (list 1 2 most-positive-fixnum)))
;;     (break* 'args "After argument evaluation")
;;     (let ((result (apply '+ args)))
;;       (break 'result "After form evaluation")
;;       result)))

At this point, trace* is likely a better fit.

Get rid of Closer MOP & Trivial Gray Streams deps

Graven Image is intended to be a drop-in portability library, but dependence on Closer MOP and Trivial Gray Streams makes the installation much more involved than it should be for a real portability library.

  • Remove Closer MOP dependency. Reimplement/import these:
    • generic-function-methods
    • method-generic-function
    • generic-function-lambda-list & method-lambda-list
    • generic-function-method-combination
    • class-slots
    • slot-definition-name
    • class-direct-superclasses
  • Trivial Gray Streams:
    • fundamental-character-output-stream
    • stream-line-column
    • stream-write-char

BREAK*

I often find myself wanting to use break for debugging, but making a good and understandable breakpoint takes:

  • Listing the name of the function/methos/flet this break belongs to.
  • Listing an event that triggered it.
  • And tying in the variables that matter.

While it all is accessible in the debugger opening for break, some more immediate info won't hurt. So the intuition for break* possible use:

;; Logging the function and args automatically:
(break "Function (~s ~{~s^ ~})." 'fn '(foo 37 a))
(break*) ;; Implying function name and args.
;; Listing the value for variable:
(break "Value for ~a is ~s" 'v v)
(break* :var v)
;; Listing data and a provided message.
(break "Function (~s ~{~s^ ~}): Message." 'fn '(foo 37 a))
(break* "Message.")

Ways to get the current stack frame (mostly from Dissect):

  • ABCL (sys:frame-to-list (cadr (sys:backtrace)))

ED* implementation plan

A rough set of features/commands (most of them have synonyms, in case we do several commands or need a replacement):

  • Edit s-expressions structurally:

    • Act on expressions
      • Move into, step in, descend
      • Move out, pop, ascend
      • Next, forward
      • Previous, back(wards)
    • Paredit
      • Insert parens
      • Wrap
      • Slurp, widen, conquer, devour
      • Barf, shorten
        • Unwrap—the same?
    • Modify expressions
      • Insert, prepend, prefix
      • Append, suffix, annex, affix, postfix
      • Change, modify, rewrite, replace
      • Delete, cut, remove, clear, kill
      • Join, merge, append?, concatenate
    • Meta
      • Copy, save
      • Search, find, grep
      • Substitute, replace
      • Paste, yank
      • Undo, cancel, stop
      • Redo
    • Evaluating, testing etc.
      • Evaluate, run, execute
      • Print, (re)display, self
      • Save, dump to the file
      • Read, parse, fetch from the file
  • Edit Lisp files as a set of s-expressions.

  • Editing strings is an UNIX ed-ish way.

    • Not really the best interface, but it's well suited for textual interaction
  • Editing non-Lisp files with this string editing modality.

    • Or defining custom processors for file types like HTML.
  • Maybe even edit arbitrary Lisp objects?

    • Kinda the same as inspect*, so not sure.

Which means ed* should dispatch at least over:

  • cons.
    • Maybe array too, which compounds to sequence.
  • string.
  • pathname.
  • And, with potential Lisp object editing, t.

CC @fstamour

Have non-parenthesized commands, like `:eval foo`

Currently, most Graven Image interfaces only read non-parenthesized commands without arguments, like :next, or parenthesized ones, like (:set x 5). Most of CL implementations have non-parenthesized commands, like :istep foo, which is convenient. While that'd complicate definterface, it's worth it to have such a syntax.

`documentation*` completeness

  • Add a slot documentation type? Really useful yet non-standard.
  • Add a package documentation type.
  • Ensure the best type order in documentation (x symbol) (doc-type (eql t))
    • Count the ratio between functions/classes etc in big projects (McClim, SICL, Nyxt).

DRIBBLE* completeness

  • Start the dribble file with an (in-package :NAME) for code reproducibility. If the package is unknown, the code might be read really wrong...
    • While 90% of REPL sessions end up in CL-USER, which is fairly reproducible, there are the remaining 10-ish percent 😰
  • Proper stream commenting and file writing (some broken, some untested)
    • ABCL
    • Allegro
    • CLASP
    • CLISP
    • Lispworks
    • Corman
    • CMUCL, SCL
    • MKCL
  • Clean up:
    • Strip REPL prompt off.
    • Remove empty lines? Not exactly true to the spec and possible output.
  • Handle errors and interactive programs gracefully.

Implementation support: Allegro

  • Y-OR-N-P*, YES-OR-NO-P*
    • Ensure that I/O (FINISH-OUTPUT etc.) is not buggy.
  • APROPOS*, APROPOS-LIST*
    • Make it fast enough.
    • Make sure that Graven Image APROPOS-LIST* returns the same
      data as the standard APROPOS-LIST when used with standard params.
      • (set-difference (apropos-list "A") (graven-image:apropos-list* "A"))
  • FUNCTION-LAMBDA-EXPRESSION* etc.
    • Name fetching.
    • Arglist fetching.
    • Closure fetching.
    • Ftype fetching.
    • Source search.
    • Generic functions support.
      • Methods support.
  • TIME*
    • Real time.
    • User run time.
    • System run time.
    • CPU cores utilized.
    • CPU cycles spent.
    • CPU load.
    • GC count.
    • GC time.
    • Bytes consed.
    • Whether the evaluation aborted.
    • Page faults.
  • DESCRIBE*, INSPECT*
    • Object IDs.
    • Object/type system specifics.
    • Implementation-specific properties.
    • MOP object inspection.
    • Proper function/funcallable hierarchy inspection.
  • DRIBBLE*
    • Trivial Gray Streams support.
    • Error output.
    • REPL prompt cleanup.
    • Empty line stripping.
  • ED*
    • Function s-expr editing.
      • Persisting the edited code into the function itself (compilation).
    • File editing.
      • Big files fetching.
      • Binary files.
      • Lisp files.
      • Plaintext files.
    • String editing.
      • Modifying the string in memory.
  • INVOKE-DEBUGGER*
    • Overriding the implementation-specific debugger.
    • Running standard debugger hooks unobtrusively.
    • Listing restarts.
    • Backtrace inspection (dissect).
      • Functions name.
      • Arguments.
      • Locals.
      • Eval-in-frame.

(WITH-)ROOM* completeness

  • Heap size/use
    • Allegro
    • CLASP
    • Lispworks
    • Corman
    • CMUCL, SCL
    • MKCL
  • Static memory size
    • ECL
    • ABCL
    • Allegro
    • CLASP
    • Lispworks
    • Corman
    • CMUCL, SCL
    • MKCL
  • Read-only memory? SBCL???
  • Immobile memory? SBCL???
  • Stack size/use
    • ECL
      • Figure out the use stats. It's mostly a C API.
    • ABCL
    • Allegro
    • CLASP
    • CLISP
    • Lispworks
    • Corman
    • CMUCL, SCL
    • MKCL
  • GC-ed space (only on CLISP)
  • GC count (only on ECL and CLISP)
  • Per thread/process memory
    • CCL: Figure out "vsp" and "tsp" stack terminology
    • SBCL
      • Can get stack for "current" thread. Means it can also get stack for other threads?
    • ECL: see Multiprocessing package and POSIX maybe.
    • ABCL
    • Allegro
    • CLASP
    • CLISP
    • Lispworks
    • Corman
    • CMUCL, SCL
    • MKCL
  • Per type breakdown
    • CCL
    • ABCL
      • Has cons count accessible via Cons class. How to get it from Lisp? Maybe other classes have count/size too?
    • Allegro
      • How does excl:print-type-counts work?
    • CLASP
    • Lispworks
    • Corman
    • CMUCL, SCL
    • MKCL

Implementation support: ABCL

  • Y-OR-N-P*, YES-OR-NO-P*
    • Ensure that I/O (FINISH-OUTPUT etc.) is not buggy.
  • APROPOS*, APROPOS-LIST*
    • Make it fast enough.
    • Make sure that Graven Image APROPOS-LIST* returns the same
      data as the standard APROPOS-LIST when used with standard params.
      • (set-difference (apropos-list "A") (graven-image:apropos-list* "A"))
  • FUNCTION-LAMBDA-EXPRESSION* etc.
    • Name fetching.
    • Arglist fetching.
    • Closure fetching.
    • Ftype fetching.
    • Source search.
    • Source parsing.
    • Generic functions support.
      • Methods support.
  • TIME*
    • Real time.
    • User run time.
    • System run time.
    • CPU cores utilized.
    • CPU cycles spent.
    • CPU load.
    • GC count.
    • GC time.
    • Bytes consed.
    • Whether the evaluation aborted.
    • Page faults.
  • DESCRIBE*, INSPECT*
    • Object IDs.
    • Object/type system specifics.
    • Implementation-specific properties.
    • Implementation-specific types/objects:
      • java:java-exception
      • mop::slot-definition
      • java:java-object
      • sys::structure-object
      • sys::structure-class
    • MOP object inspection.
    • Proper function/funcallable hierarchy inspection.
  • DRIBBLE*
    • Trivial Gray Streams support.
    • Error output.
    • REPL prompt cleanup.
    • Empty line stripping.
  • ED*
    • Function s-expr editing.
      • Persisting the edited code into the function itself (compilation).
    • File editing.
      • Big files fetching.
      • Binary files.
      • Lisp files.
      • Plaintext files.
    • String editing.
      • Modifying the string in memory.
  • INVOKE-DEBUGGER*
    • Overriding the implementation-specific debugger.
    • Running standard debugger hooks unobtrusively.
    • Listing restarts.
    • Backtrace inspection (dissect).
      • Functions name.
      • Arguments.
      • Locals.
      • Eval-in-frame.

Implementation support: ECL

  • Y-OR-N-P*, YES-OR-NO-P*
    • Ensure that I/O (FINISH-OUTPUT etc.) is not buggy.
  • APROPOS*, APROPOS-LIST*
    • Make it fast enough
    • Make sure that Graven Image APROPOS-LIST* returns the same
      data as the standard APROPOS-LIST when used with standard params.
      • (set-difference (apropos-list "A") (graven-image:apropos-list* "A"))
  • FUNCTION-LAMBDA-EXPRESSION* etc.
    • Name fetching.
    • Arglist fetching.
    • Closure fetching.
    • Ftype fetching.
    • Source search.
    • Source parsing.
    • Generic functions support.
      • Methods support.
  • TIME*
    • Real time.
    • User run time.
    • System run time.
    • CPU cores utilized.
    • CPU cycles spent.
    • CPU load.
    • GC count.
    • GC time.
    • Bytes consed.
    • Whether the evaluation aborted.
    • Page faults.
  • DESCRIBE*, INSPECT*
    • Object IDs.
    • Object/type system specifics.
    • Implementation-specific properties.
    • Implementation-specific types/objects.
    • MOP object inspection.
    • Proper function/funcallable hierarchy inspection.
  • DRIBBLE*
    • Trivial Gray Streams support.
    • Error output.
    • REPL prompt cleanup.
    • Empty line stripping.
  • ED*
    • Function s-expr editing.
      • Persisting the edited code into the function itself (compilation).
    • File editing.
      • Big files fetching.
      • Binary files.
      • Lisp files.
      • Plaintext files.
    • String editing.
      • Modifying the string in memory.
  • INVOKE-DEBUGGER*
    • Overriding the implementation-specific debugger.
    • Running standard debugger hooks unobtrusively.
    • Listing restarts.
    • Backtrace inspection (dissect).
      • Functions name.
      • Arguments.
      • Locals.
      • Eval-in-frame.

APROPOS(-LIST)* completeness

  • Speed up on ECL.
  • Add case-sensitivity setting, like in Allegro.
    • Maybe refactor the arguments to keyword args—it's getting too crowded for optional ones.
  • Alighnment? Line breaking?

Fix DRIBBLE* on ABCL

On 1.9.2, ABCL recognises Gray Streams as streams, but now it complains about missing methods for all the dribble streams. Methods it asked me before I've given up: gray-streams::gray-stream-element-type and gray-streams:stream-write-string.

Weird stuff that needs deep research and fixing.

  • Implement stream-write-string with stream-write-char.

YES-OR-NO-P* and Y-OR-N-P* completeness

  • Adjust printing to options (i.e. print (a[y] or [n]ay) when ay and nay are the only options).
  • Maybe make yes-or-no-p* stricter after all?
  • Add general prompting facility? Some implementations have it as part of debugger or top level loop.

Speed up loading

Now that I've included Graven Image into my default config, ABCL takes 13+ seconds to start, with most of the time dedicated to Graven Image compilation. Is there any way to speed it up? How do ASDF/UIOP achieve instantaneous loading?

Smarter `describe*`

On SBCL, describing a bound symbol generates a HUGE wall of text with all the slots of the bound class, all the methods of the bound function etc. For nyxt:buffer, it's:

NYXT:BUFFER
  [symbol]

BUFFER names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Auto-generated accessor function for slot BUFFER.
  Method-combination: STANDARD
  Methods:
    (BUFFER (PASSWORD-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (PROMPT-BUFFER-COMMAND-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (HISTORY-ALL-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (HISTORY-ALL-OWNER-NODES-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (ALL-HISTORY-FORWARDS-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (HISTORY-FORWARDS-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (DIRECT-HISTORY-FORWARDS-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (HISTORY-BACKWARDS-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (SEARCH-BUFFER-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (SEARCH-MATCH))
      Documentation:
        The buffer where the match is found.
    (BUFFER (FRAME-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (HEADING-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (HEADING))
      Documentation:
        The buffer to which this heading belongs.
    (BUFFER (DEBUG-WRAPPER))
      Documentation:
        The buffer debugger is open in for this condition.
    (BUFFER (EXTENDED-COMMAND-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (COMMAND-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (REQUEST-DATA))
      Documentation:
        Buffer targeted by the request.
    (BUFFER (HISTORY-DISOWNED-SOURCE))
      Documentation:
        automatically generated reader method
    (BUFFER (MODE))
      Documentation:
        automatically generated reader method
    (BUFFER (KEYWORD-SOURCE))
      Documentation:
        automatically generated reader method

(SETF BUFFER) names a generic function:
  Lambda-list: (NEW-VALUE OBJECT)
  Argument precedence order: (NEW-VALUE OBJECT)
  Derived type: (FUNCTION (T T) *)
  Documentation:
    Auto-generated accessor function for slot BUFFER.
  Method-combination: STANDARD
  Methods:
    ((SETF BUFFER) (T PASSWORD-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T PROMPT-BUFFER-COMMAND-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T HISTORY-ALL-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T HISTORY-ALL-OWNER-NODES-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T ALL-HISTORY-FORWARDS-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T HISTORY-FORWARDS-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T DIRECT-HISTORY-FORWARDS-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T HISTORY-BACKWARDS-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T SEARCH-BUFFER-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T SEARCH-MATCH))
      Documentation:
        The buffer where the match is found.
    ((SETF BUFFER) (T FRAME-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T HEADING-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T HEADING))
      Documentation:
        The buffer to which this heading belongs.
    ((SETF BUFFER) (T DEBUG-WRAPPER))
      Documentation:
        The buffer debugger is open in for this condition.
    ((SETF BUFFER) (T EXTENDED-COMMAND-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T COMMAND-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T REQUEST-DATA))
      Documentation:
        Buffer targeted by the request.
    ((SETF BUFFER) (T HISTORY-DISOWNED-SOURCE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T MODE))
      Documentation:
        automatically generated writer method
    ((SETF BUFFER) (T KEYWORD-SOURCE))
      Documentation:
        automatically generated writer method

BUFFER names the user-class #<NYXT:USER-CLASS NYXT:BUFFER>:
  Documentation:
    A buffer is the fundamental unit of displayed content.
    Buffers result from the computations of a web renderer, which generates a visual
    representation of HTML documents.
    
    Rendered URLs or the Nyxt's manual qualify as examples.  Buffers are fully
    separated from one another, so that each has its own behavior and settings.
  Class precedence-list: NYXT:BUFFER, NYXT:RENDERER-BUFFER, NYXT/RENDERER/GTK:GTK-BUFFER, STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: NYXT:RENDERER-BUFFER
  Direct subclasses: NYXT:NETWORK-BUFFER, NYXT:CONTEXT-BUFFER, NYXT:DOCUMENT-BUFFER, NYXT:INPUT-BUFFER, NYXT:MODABLE-BUFFER
  Direct slots:
    NYXT:DEFAULT-MODES
      Type: (NYXT/TYPES:LIST-OF SYMBOL)
      Initargs: :DEFAULT-MODES
      Initform: NYXT::%DEFAULT-MODES
      Documentation:
       The symbols of the modes to instantiate on buffer creation.
       The mode instances are stored in the `modes' BUFFER slot.
       
       The default modes returned by this method are appended to the default modes
       inherited from the superclasses.
    NYXT:ID
      Type: UNSIGNED-BYTE
      Initargs: :ID
      Initform: (NYXT/UTILITIES:NEW-ID)
      Readers: NYXT:ID
      Writers: (SETF NYXT:ID)
      Documentation:
       Unique identifier for a buffer.
    NYXT:PROFILE
      Type: NYXT:NYXT-PROFILE
      Initargs: :PROFILE
      Initform: (NYXT:GLOBAL-PROFILE)
      Readers: NYXT:PROFILE
      Writers: (SETF NYXT:PROFILE)
      Documentation:
       Buffer profiles are used to specialize the behavior of
       various parts, such as the path of all data files.
       See also the `profile' slot in the `browser' class.
    NYXT:URL
      Initargs: :URL
      Initform: (QURI.URI:URI "")
      Readers: NYXT:URL
      Writers: (SETF NYXT:URL)
    NYXT:URL-AT-POINT
      Initargs: :URL-AT-POINT
      Initform: (QURI.URI:URI "")
      Readers: NYXT:URL-AT-POINT
      Writers: (SETF NYXT:URL-AT-POINT)
    NYXT:TITLE
      Type: STRING
      Initargs: :TITLE
      Initform: ""
      Readers: NYXT:TITLE
      Writers: (SETF NYXT:TITLE)
    NYXT:STYLE
      Initargs: :STYLE
      Initform: (THEME:THEMED-CSS (NYXT:THEME NYXT:*BROWSER*)
                  `(:FONT-FACE :FONT-FAMILY #1="public sans" :FONT-STYLE #2="normal" :FONT-WEIGHT #3="400" :SRC
                    ,(FORMAT NIL #4="url('nyxt-resource:~a')" "PublicSans-Regular.woff") #5="format('woff')")
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #6="italic" :FONT-WEIGHT #3# :SRC
                    ,(FORMAT NIL #4# "PublicSans-Italic.woff") #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #2# :FONT-WEIGHT #7="100" :SRC ,(FORMAT NIL #4# "PublicSans-Thin.woff") #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #6# :FONT-WEIGHT #7# :SRC ,(FORMAT NIL #4# "PublicSans-ThinItalic.woff")
                    #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #2# :FONT-WEIGHT #8="200" :SRC
                    ,(FORMAT NIL #4# "PublicSans-ExtraLight.woff") #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #6# :FONT-WEIGHT #8# :SRC
                    ,(FORMAT NIL #4# "PublicSans-ExtraLightItalic.woff") #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #2# :FONT-WEIGHT #9="300" :SRC ,(FORMAT NIL #4# "PublicSans-Light.woff")
                    #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #6# :FONT-WEIGHT #9# :SRC ,(FORMAT NIL #4# "PublicSans-LightItalic.woff")
                    #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #2# :FONT-WEIGHT #10="500" :SRC ,(FORMAT NIL #4# "PublicSans-Medium.woff")
                    #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #6# :FONT-WEIGHT #10# :SRC ,(FORMAT NIL #4# "PublicSans-MediumItalic.woff")
                    #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #2# :FONT-WEIGHT #11="600" :SRC
                    ,(FORMAT NIL #4# "PublicSans-SemiBold.woff") #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #6# :FONT-WEIGHT #11# :SRC
                    ,(FORMAT NIL #4# "PublicSans-SemiBoldItalic.woff") #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #2# :FONT-WEIGHT #12="700" :SRC ,(FORMAT NIL #4# "PublicSans-Bold.woff")
                    #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #6# :FONT-WEIGHT #12# :SRC ,(FORMAT NIL #4# "PublicSans-BoldItalic.woff")
                    #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #2# :FONT-WEIGHT #13="800" :SRC
                    ,(FORMAT NIL #4# "PublicSans-ExtraBold.woff") #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #6# :FONT-WEIGHT #13# :SRC
                    ,(FORMAT NIL #4# "PublicSans-ExtraBoldItalic.woff") #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #2# :FONT-WEIGHT #14="900" :SRC ,(FORMAT NIL #4# "PublicSans-Black.woff")
                    #5#)
                  `(:FONT-FACE :FONT-FAMILY #1# :FONT-STYLE #6# :FONT-WEIGHT #14# :SRC ,(FORMAT NIL #4# "PublicSans-BlackItalic.woff")
                    #5#)
                  `(* :FONT-FAMILY ,THEME:FONT-FAMILY :BOX-SIZING NYXT::BORDER-BOX)
                  `(NYXT::BODY :BACKGROUND-COLOR ,THEME:BACKGROUND :COLOR ,THEME:ON-BACKGROUND :MARGIN-LEFT #15="20px" :MARGIN-TOP #15#)
                  `(NYXT::UL :MARGIN-TOP #16="0" :MARGIN-BOTTOM #16#)
                  `("details > *" :MARGIN-LEFT "18px")
                  `("details > ul" :MARGIN-LEFT #17="inherit")
                  `("details summary" :MARGIN-LEFT #17# :MARGIN-BOTTOM "8px" :CURSOR #18="pointer")
                  `("summary::-webkit-details-marker" :PADDING-BOTTOM "4px")
                  `(NYXT::.SECTION :MARGIN-TOP #19="2em")
                  `("h1" :FONT-SIZE "44px")
                  `("h2" :FONT-SIZE "36px")
                  `("h3" :FONT-SIZE "32px")
                  `("h4" :FONT-SIZE "28px")
                  `("h5" :FONT-SIZE "24px")
                  `("h6" :FONT-SIZE #15#)
                  `("p" :FONT-SIZE "16px")
                  `("h1,h2,h3,h4,h5,h6" :COLOR ,THEME:PRIMARY :FONT-FAMILY ,THEME:FONT-FAMILY)
                  `(NYXT::HR :BACKGROUND-COLOR ,THEME:SECONDARY :COLOR ,THEME:ON-SECONDARY :HEIGHT #20="3px" :BORDER-RADIUS "2px"
                    :BORDER-WIDTH #16#)
                  `(NYXT::BUTTON :BACKGROUND "transparent" :COLOR #17# :BORDER #21="none" :PADDING 0 :FONT #17# :OUTLINE #17#)
                  `(NYXT::.BUTTON :APPEARANCE "menulist-button" :BACKGROUND-COLOR ,THEME:PRIMARY :COLOR ,THEME:ON-PRIMARY :DISPLAY
                    #22="inline-block" :TEXT-DECORATION #21# :BORDER-RADIUS #23="0.1em" :BORDER-COLOR ,THEME:PRIMARY :BORDER-STYLE
                    #24="solid" :BORDER-WIDTH #25="0.2em" :PADDING #25# :MARGIN #25# :MIN-HEIGHT #26="2rem")
                  `(NYXT::SELECT.BUTTON :APPEARANCE NYXT::AUTO :BACKGROUND-COLOR ,THEME:PRIMARY NYXT::!IMPORTANT :COLOR
                    ,(THEME:CONTRASTING-TEXT-COLOR THEME:THEME #27="white") NYXT::!IMPORTANT :MIN-HEIGHT #26#)
                  `((:AND NYXT::.BUTTON :HOVER) :CURSOR #18# :OPACITY 0.8)
                  `((:AND NYXT::.BUTTON (:OR :VISITED :ACTIVE)) :COLOR ,THEME:BACKGROUND)
                  `(NYXT::.LINK :APPEARANCE NYXT::NONE :TEXT-DECORATION "underline" :DISPLAY "inline" :COLOR ,THEME:PRIMARY)
                  `(".link:hover" :OPACITY 0.8)
                  `(NYXT::.ACTION :COLOR ,THEME:ACTION
                    (NYXT::.BUTTON :BACKGROUND-COLOR ,THEME:ACTION :COLOR ,THEME:ON-ACTION :BORDER-COLOR ,THEME:ACTION+))
                  `(NYXT::.WARNING :COLOR ,THEME:WARNING
                    (NYXT::.BUTTON :BACKGROUND-COLOR ,THEME:WARNING :COLOR ,THEME:ON-WARNING :BORDER-COLOR ,THEME:WARNING+))
                  `(NYXT::.SUCCESS :COLOR ,THEME:SUCCESS
                    (NYXT::.BUTTON :BACKGROUND-COLOR ,THEME:SUCCESS :COLOR ,THEME:ON-SUCCESS :BORDER-COLOR ,THEME:SUCCESS+))
                  `(NYXT::.HIGHLIGHT :COLOR ,THEME:HIGHLIGHT
                    (NYXT::.BUTTON :BACKGROUND-COLOR ,THEME:HIGHLIGHT :COLOR ,THEME:ON-HIGHLIGHT :BORDER-COLOR ,THEME:HIGHLIGHT+))
                  `(NYXT::.HIGHLIGHT :COLOR ,THEME:HIGHLIGHT)
                  `(NYXT::.BUTTON.HIGHLIGHT :BACKGROUND-COLOR ,THEME:HIGHLIGHT :COLOR ,THEME:ON-HIGHLIGHT :BORDER-COLOR
                    ,THEME:HIGHLIGHT+)
                  `(NYXT::.PLAIN :COLOR ,THEME:ON-BACKGROUND :BACKGROUND-COLOR ,THEME:BACKGROUND)
                  `(NYXT::.INPUT :APPEARANCE "textfield" :DISPLAY #22# :COLOR "black" :BACKGROUND-COLOR #27# :BORDER #25# NYXT::SOLID
                    ,THEME:SECONDARY :BORDER-RADIUS #23# :OUTLINE #21# :PADDING #25# :MARGIN #25#)
                  `(NYXT::A :COLOR ,THEME:PRIMARY)
                  `("a:hover" :OPACITY 0.8)
                  `(NYXT::PRE :BORDER-RADIUS #20# :OVERFLOW "auto" :PADDING "5px")
                  `("table" :BORDER-RADIUS #20# :BORDER-SPACING #16# :WIDTH "100%")
                  `("pre, p code" :COLOR ,THEME:ON-CODEBLOCK :BACKGROUND-COLOR ,THEME:CODEBLOCK)
                  `("a code" :TEXT-DECORATION NYXT::UNDERLINE)
                  `("table, th, td" :BORDER-COLOR ,THEME:SECONDARY :BORDER-WIDTH "1px" :BORDER-STYLE #24# :BACKGROUND-COLOR
                    ,THEME:BACKGROUND :COLOR ,THEME:ON-BACKGROUND)
                  `("td, th" :PADDING "6px")
                  `(NYXT::TH :BACKGROUND-COLOR ,THEME:PRIMARY :COLOR ,THEME:ON-PRIMARY :TEXT-ALIGN "left")
                  `(NYXT::DT :FONT-WEIGHT "bold" :MARGIN-TOP #19#)
                  `("::selection" :COLOR ,THEME:ON-ACTION :BACKGROUND-COLOR ,THEME:ACTION))
      Readers: NYXT:STYLE
      Writers: (SETF NYXT:STYLE)
    NYXT:BUFFER-DELETE-HOOK
      Type: NYXT::HOOK-BUFFER
      Initargs: :BUFFER-DELETE-HOOK
      Initform: (MAKE-INSTANCE 'NYXT::HOOK-BUFFER)
      Readers: NYXT:BUFFER-DELETE-HOOK
      Writers: (SETF NYXT:BUFFER-DELETE-HOOK)
      Documentation:
       Hook run before `buffer-delete' takes effect.
       The handlers take the buffer as argument.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.