Gibt es Lisp-Codecompiler?

Viele Lisp-Compiler kompilieren, um "native" - code. "Native" bedeutet hier "machine code" (x86-32bit oder 64bit-Modus, PowerPC, SPARC, ...).

Andere Fragen:

• kann 'non-native-code-Compiler erzeugen, eine einzige Datei, ausführbare Dateien? -> ja.

• kann 'native-code-Compiler erzeugen, eine einzige Datei, ausführbare Dateien? -> ja.

• wie 'native' ist 'native'? -> Lisp-system die meisten der Zeit, haben Ihre eigenen internen Daten-Struktur-Layouts (CLOS-Klassen), Ihre eigene Fehlerbehandlung ("Bedingungen"), die Ihre eigene Speicherverwaltung (garbage collection), die Ihre eigenen Bibliotheken, ...

• kann Lisp laufen ohne GC? -> in der Regel nicht. Es gibt auch Ausnahmen.

• was über die Anwendung Größe? -> standardmäßig einfache Weise generiert Lisp-Anwendung führen oft zu großen ausführbaren Dateien. Die ausführbaren Dateien sind den ganzen Lisp-einschließlich seiner Bibliothek, die Namen aller Symbole, Informationen über die Argumente zu Funktionen, die compiler, debugger, source code, location information, und mehr. Einige Compiler erzeugen auch groessere code (SBCL ist ein Beispiel).

• Möglichkeiten gibt es, zu schrumpfen Anwendung Größen? -> das hängt von der Lisp-system. Kommerzielle Lisp-Systeme wie LispWorks und Allegro CL kann. Für application delivery, Sie können entfernen Sie unbenutzte code, entfernen von debugging-Informationen, entfernen Sie Teile des Lisp (Bibliotheken, compiler, ...) und vieles mehr.

• können Common Lisp-Systeme erzeugen kleine ausführbare Dateien. Ich meine wirklich kleine. -> Nicht wirklich. Die Programme sind entweder große (CCL) oder sehr groß (SBCL). Einige Common Lisp-Systeme erzeugen kann, die mittlere ausführbaren Dateien. Aber keiner kann wirklich erzeugen kleine ausführbare Dateien.

• gibt es wirklich keine Möglichkeit generieren sehr kleine ausführbare Dateien? -> Jahren-Compiler geschrieben wurden, die einen relativ kompakten C-code ohne großen Bibliotheken. Aber diese Compiler sind nicht gepflegt.

• gibt es andere Möglichkeiten zu schrumpfen, ausführbare Dateien? -> Wenn Sie wollen, mehr als einen Lisp-Anwendung, macht es Sinn, Wiederverwendung runtime, compiler, Bibliotheken, die in eine oder mehrere shared-libraries. So, den code zu liefern, wird kleiner sein, wenn eine runtime bereits installiert ist als eine shared library (oder ähnlich).

• wie finde ich heraus, was die Lisp-ich bin mit unterstützt als application delivery? -> Lesen Sie das Handbuch und Fragen Sie andere Benutzer.

• okay, also die meisten Common Lisp-Systeme können nicht generieren, winzige Anwendungen. Gibt es andere Lisp-Dialekte, die generieren können kleinere executables. -> ja, einige Schema-Compiler können.

• wie funktioniert Common Lisp behandeln von Laufzeitfehlern? -> hängt davon ab, wie Sie die Anwendung generieren. Standardmäßig erhalten Sie eine Lisp-debugger (es sei denn, Sie haben es entfernt). Aber Sie können Ihre eigenen Fehler-handling-Routinen in Ihrer Anwendung und können verhindern, dass der debugger erscheint.

• was sind Common Lisp Besondere stärken bei der Erzeugung von wirklich kleinen ausführbaren Dateien nicht? -> Sie können auch eine REPL, um mit der Anwendung interagieren, können Sie mit einem mitgelieferten compiler zu kompilieren, die neue (oder geänderte code) zur Laufzeit, die Sie verwenden können, die FASL (compiled Lisp-code) loader zum LADEN von zusätzlichen nativen code zur Laufzeit (denken, plugins, patches, Erweiterungen, ...), ausgefeilte Fehlerbehandlung einschließlich error-recovery ist möglich, ...

• aber Lisp ist dynamisch? -> ja, dynamisch bedeutet, dass es kann viele Dinge, die während der Laufzeit. Zum Beispiel in Common Lisp, die Sie ändern können, eine CLOS-Klasse zur Laufzeit und die Klasse' Instanzen übernehmen, um die änderungen. Aber die verschiedenen Lisp-Systeme haben verschiedene Möglichkeiten, um entfernen Sie einige der dynamischen Eigenschaften. Strukturen sind weniger dynamisch als CLOS-Klassen. Sie können erklären, Arten und kompilieren mit unterschiedlichen Optimierungen (Geschwindigkeit, Sicherheit, debug, ...). Sie können inline-Funktionen. Und mehr.

Einen einfachen Weg, um zu sehen, die den kompilierten code für die Funktionen ist die Verwendung der Common Lisp-Funktion zu ZERLEGEN. Beispiel in Clozure CL auf einem x86-64-Mac -

? (defun foo (x y) (if (= x y) (sin x) (* y (cos x))))
FOO
? (disassemble 'foo)
L0
  [0]     (leaq (@ (:^ L0) (% rip)) (% fn))
  [7]     (cmpl ($ 16) (% nargs))
  [10]    (jne L209)
  [16]    (pushq (% rbp))
  [17]    (movq (% rsp) (% rbp))

...

  [172]   (pushq (@ 77752))
  [179]   (jmpq (@ 10 (% temp0)))
L189
  [189]   (leaq (@ (:^ L0) (% rip)) (% fn))
  [196]   (jmpq (@ .SPNVALRET))
L209
  [209]   (uuo-error-wrong-number-of-args)
NIL

Die Ausgabe ZERLEGEN, offensichtlich, hängt von der Prozessor-Architektur, das Betriebssystem, die verwendete Lisp-compiler und den aktuellen Optimierungseinstellungen.

InformationsquelleAutor der Antwort Rainer Joswig

Gibt es riesige zahlen von Lisp-Compiler in systemeigenen code, siehe http://www.thefreecountry.com/compilers/commonlisp.shtml und z.B. die CMU-Common-Lisp-Compiler.

InformationsquelleAutor der Antwort Alex Martelli

Vergessen Sie nicht Huhn Schema.

InformationsquelleAutor der Antwort Jonathan Arkell