Schreiben Sie auf der Grundlage eines Kommentars von George Edison zu dieser Frage den kleinsten selbstübersetzenden Dolmetscher.

• Sie können die Sprache Ihrer Wahl verwenden.
• Leere Sprachen zählen nicht. Ihr Programm muss mindestens zwei Zeichen lang sein.
• Das Programm muss nicht die gesamte Sprache interpretieren, sondern nur eine vollständige Teilmenge der Sprachfunktionen (die den Interpreter enthält).
• Quines zählen nicht.
• Verwenden Sie nicht die in Ihrer Sprache integrierte evalFunktion oder eine gleichwertige Funktion. Gleiches gilt für applyusw.

CI - 260

,(1p0(2d())(41(2d())('#((1p0()(10()(1d,1p$)=)<)$2d,1p$)(40(1d,1c$^)(''(1d,^)('0
'9('0-(,'0'9('0-2p10*+1p$)(!1d)~)$^)(0($)'$(^)'^(&)'&(c)'c(p)'p(d)'d(=)'=(<)'<(
>)'>(~)'~(.)'.(,)',(!)'!(+)'+(-)'-(*)'*(/)'/(%)'%()38p(1p3p0(3d)((2)(3)=p1d1p$)
=)$)~)=)=,2p$&)=)=)<)$$

320 → 260: Schieben Sie einfache Zuordnungen von Zeichen zu Anweisungen und falten Sie sie dann um. Dies halbiert die Codegröße pro Fall (es gibt 18 Fälle), kostet jedoch 30 Zeichen, um das Falten durchzuführen.

Dies ist eine weitere von mir erstellte Sprache ( Basisinterpreter auf Gist ). Es ist einzigartig, dass die Sprache Codefragmente reifiziert. Das heißt, Befehlsfolgen in dieser stapelbasierten Sprache werden in gleicher Weise verwendet wie Datenstrukturen oder Abschlüsse in anderen Sprachen:

1^      # Push a 1, and "lift" it to be a code literal.
(5 +)   # Define a code literal.
&       # Join the two code literals, forming (1 5 +)
$       # Execute the code literal.

Der Interpreter erstellt ein Codefragment des gesamten Programms, bevor er es ausführt, sodass es auch als Compiler betrachtet werden kann. Aus diesem Grund führt das Stapeln des Interpreters nicht zu einem exponentiellen Laufzeitaufwand.

Der Interpreter leitet alle seine Operatoren direkt vom Host-Interpreter ab. Das Parsen wird jedoch von selbst durchgeführt, sodass der Großteil des Codes nur aus Sequenzen besteht, die Zeichen in ihre jeweiligen Codeliterale übersetzen. Dies ist nicht dasselbe wie die Verwendung eval, zeigt jedoch, wie abhängig eine Implementierung einer Programmiersprache von der Semantik ihrer Host-Sprache / Architektur ist.

Sprach-Referenz:

Holen Sie sich den Dolmetscher hier

Blöcke

• ( ... )

  Erstellen Sie einen "Block", der praktisch eine Liste von Anweisungen ohne Kontext ist. Intern könnte es sogar Maschinencode sein.

• Block $

  Rufen Sie einen Block auf. Der Angerufene erhält den globalen Stapel, der den aufgerufenen Block enthält.

• Wert ^

  Heben Sie einen Wert an. Machen Sie daraus einen Block, der diesen Wert überträgt.

  Beispiel :

     1 ^
  == (1)
  

• Block1 Block2 &

  Verbinden Sie zwei Blöcke und bilden Sie einen, der beide nacheinander ausführt.

  Beispiel :

     (1) (2) &
  == (1 2)
  

Stapelbearbeitung

• n c

  Kopieren Sie den n-ten Wert des Stapels.

  Beispiel :

     5 4 3 2 1 0 3c
  == 5 4 3 2 1 0 3
  

• n p

  Zupfe den n-ten Wert des Stapels (entferne ihn und bringe ihn nach vorne).

  Beispiel :

     5 4 3 2 1 0 3p
  == 5 4 2 1 0 3
  

• n d

  Löschen Sie n Werte vom Stapel. 0dist ein No-Op.

  Beispiel :

     5 4 3 2 1 0 3d
  == 5 4 3
  

Vergleichsoperatoren

• ab (on_true) (on_false) =

  Teste ob a gleich b ist. Verbrauchen Sie alle Argumente außer dem ersten und rufen Sie on_true oder on_false auf. Wenn ein Argument Null ist und das andere einen anderen Typ hat, ist das Ergebnis falsch. Andernfalls müssen a und b ganze Zahlen sein.

  Beispiel :

     3 3 ('0+ .) (1d) =
  == 3 '0+ .
  

• ab (on_true) (on_false) <

  Testen Sie, ob a kleiner als b ist. a und b müssen ganze Zahlen sein.

  Beispiel :

     3 5 (1d 5) () <
  == 3 1d 5
  == 5
  

• ab (on_true) (on_false) >

  Testen Sie, ob a größer als b ist. a und b müssen ganze Zahlen sein.

  Beispiel :

     3 5 (1d 5) () >
  == 3
  

• a lo hi (on_true) (on_false) ~

  Testen Sie, ob lo <= a <= hi ist. a, lo und hi müssen ganze Zahlen sein.

  Beispiel :

     3 0 10 ('0+ .) (1d) ~
  == 3 '0+ .
  

I / O

• c .

  Setze das Zeichen c (verbrauche es vom Stapel).

• ,

  Holen Sie sich einen Charakter und schieben Sie ihn auf den Stapel. Wenn das Dateiende erreicht ist, wird -1 gedrückt.

• c !

  Unget einen Charakter. Genau wie bei ungetc in C ist nur ein Pushback zulässig.

Ganzzahlige Literale

• 'c

  Drücken Sie den Buchstaben c.

• [0-9] +

  Geben Sie eine Dezimalzahl ein.

Arithmetik

• ab +
• ab -

• ab *

  Addiere / subtrahiere / multipliziere zwei Zahlen.

  Beispiel :

     3 5 + 7 3 + *
  == 80
  

• ab /

• ab %

  Division und Modul. Anders als in C runden sich diese gegen negative Unendlichkeit ab.

Sonstiges

• Code #Kommentar

  Der #Charakter kommentiert alles bis zum Ende der Zeile aus.

• )

  Dient zum Beenden von Blöcken. Kann auch zum Beenden des gesamten Programms verwendet werden.

• Alle anderen Zeichen werden ignoriert.

Binäre Lambda-Rechnung, 232 Bits (29 Bytes)

0101000110100000000101011000000000011110000101111110011110000101110011110000001111000010110110111001111100001111100001011110100111010010110011100001101100001011111000011111000011100110111101111100111101110110000110010001101000011010

Weitere Informationen finden Sie unter http://en.wikipedia.org/wiki/Binary_lambda_calculus#Lambda_encoding

Ich kann das nicht würdigen , aber ich dachte, ich würde dieses erstaunliche teilen:

Brainf *** (423)

>>>+[[-]>>[-]++>+>+++++++[<++++>>++<-]++>>+>+>+++++[>++>++++++<<-]+>>>,<++[[>[
->>]<[>>]<<-]<[<]<+>>[>]>[<+>-[[<+>-]>]<[[[-]<]++<-[<+++++++++>[<->-]>>]>>]]<<
]<]<[[<]>[[>]>>[>>]+[<<]<[<]<+>>-]>[>]+[->>]<<<<[[<<]<[<]+<<[+>+<<-[>-->+<<-[>
+<[>>+<<-]]]>[<+>-]<]++>>-->[>]>>[>>]]<<[>>+<[[<]<]>[[<<]<[<]+[-<+>>-[<<+>++>-
[<->[<<+>>-]]]<[>+<-]>]>[>]>]>[>>]>>]<<[>>+>>+>>]<<[->>>>>>>>]<<[>.>>>>>>>]<<[
>->>>>>]<<[>,>>>]<<[>+>]<<[+<<]<]

BlockScript - 535

{[B':=?0:B';=?0:B'}=?0:B'{=?,A!,A!d1c&:B'?=?,A!,A!2e&:B''=?,,A!d3c&:B{[B'0<?0:B
'9>?0:1}!?B'0-{[,g!?c'0-B10*d+A!:Bd]A!d3c&}!:B'#=?{[,10=?,]A!:A!}!:,A!Bb&}{[AC[
B]DB?[AB{[Bh&hbhn!}{[B[AB]C?1-eA!:b}&[C1=?E[C]FHc&B!:C2=?{G?D:E[C}!FHcI!:C3=?E[
C]B!:C'!=?G[ABC]Hc&dbh&D?b@I!B!:b@I!:C'&=?HB!:C'@=?FGDI!:C'[=?GF&HDI!:C']=?F[A]
HDI!:C',=?,B!:C'.=?G.FHDI!:C'a'z{[DC<?0:DB>?0:1}!?Ce-HA!B!:C'A'Ze!?F[B]Cg-dA!B!
:{C'+=?{[CB+}:C'-=?{[CB-}:C'*=?{[CB*}:C'/=?{[CB/}:C'%=?{[CB%}:C'<=?{[CB<}:C'>=?
{[CB>}:C'==?{[CB=}:0}!?H[A][B]Ge!B!:FHDI!:c},c!0ac&0&0&0bho!;

BlockScript ist eine einfache Spaghetti-Stack- basierte Sprache, die ich speziell für diese Herausforderung entwickelt habe. Der Basisinterpreter ist blockscript.c .

Beispielprogramm (druckt die ersten 15 Fibonacci-Zahlen):

{[B?B10/A!B10%d&:0}
{[B0<?'-.0B-A!:{B?Bh!{[B?B[A]A!B[B]'0+.:}!:'0.}!10.}
{[B?Dd!DC+B1-CecA!:}
0 1 15d!
;

Der Interpreter liest sowohl den Quellcode als auch die Programmeingabe von der Standardeingabe in dieser Reihenfolge. Dies bedeutet, dass Sie zum Ausführen eines Interpreters innerhalb eines Interpreters einfach Folgendes kopieren und einfügen:

# Level 1
{[B':=?0:B';=?0:B'}=?0:B'{=?,A!,A!d1c&:B'?=?,A!,A!2e&:B''=?,,A!d3c&:B{[B'0<?0:B
'9>?0:1}!?B'0-{[,g!?c'0-B10*d+A!:Bd]A!d3c&}!:B'#=?{[,10=?,]A!:A!}!:,A!Bb&}{[AC[
B]DB?[AB{[Bh&hbhn!}{[B[AB]C?1-eA!:b}&[C1=?E[C]FHc&B!:C2=?{G?D:E[C}!FHcI!:C3=?E[
C]B!:C'!=?G[ABC]Hc&dbh&D?b@I!B!:b@I!:C'&=?HB!:C'@=?FGDI!:C'[=?GF&HDI!:C']=?F[A]
HDI!:C',=?,B!:C'.=?G.FHDI!:C'a'z{[DC<?0:DB>?0:1}!?Ce-HA!B!:C'A'Ze!?F[B]Cg-dA!B!
:{C'+=?{[CB+}:C'-=?{[CB-}:C'*=?{[CB*}:C'/=?{[CB/}:C'%=?{[CB%}:C'<=?{[CB<}:C'>=?
{[CB>}:C'==?{[CB=}:0}!?H[A][B]Ge!B!:FHDI!:c},c!0ac&0&0&0bho!;

# Level 2
{[B':=?0:B';=?0:B'}=?0:B'{=?,A!,A!d1c&:B'?=?,A!,A!2e&:B''=?,,A!d3c&:B{[B'0<?0:B
'9>?0:1}!?B'0-{[,g!?c'0-B10*d+A!:Bd]A!d3c&}!:B'#=?{[,10=?,]A!:A!}!:,A!Bb&}{[AC[
B]DB?[AB{[Bh&hbhn!}{[B[AB]C?1-eA!:b}&[C1=?E[C]FHc&B!:C2=?{G?D:E[C}!FHcI!:C3=?E[
C]B!:C'!=?G[ABC]Hc&dbh&D?b@I!B!:b@I!:C'&=?HB!:C'@=?FGDI!:C'[=?GF&HDI!:C']=?F[A]
HDI!:C',=?,B!:C'.=?G.FHDI!:C'a'z{[DC<?0:DB>?0:1}!?Ce-HA!B!:C'A'Ze!?F[B]Cg-dA!B!
:{C'+=?{[CB+}:C'-=?{[CB-}:C'*=?{[CB*}:C'/=?{[CB/}:C'%=?{[CB%}:C'<=?{[CB<}:C'>=?
{[CB>}:C'==?{[CB=}:0}!?H[A][B]Ge!B!:FHDI!:c},c!0ac&0&0&0bho!;

# Level 3
{[B?B10/A!B10%d&:0}
{[B0<?'-.0B-A!:{B?Bh!{[B?B[A]A!B[B]'0+.:}!:'0.}!10.}
{[B?Dd!DC+B1-CecA!:}
0 1 15d!
;

Wie im Film Inception kann man nicht tiefer als drei Ebenen gehen. Es ist keine Frage der Zeit, sondern des Raums. BlockScript leckt den Speicher stark, und dies hängt davon ab, wie die Sprache selbst gestaltet ist.

Sprach-Referenz:

Holen Sie sich den Dolmetscher hier

In BlockScript ist der "Stapel" kein Array, das durch nachfolgende Operationen überschrieben wird, wie Sie es möglicherweise gewohnt sind. Es ist tatsächlich als unveränderliche verknüpfte Liste implementiert, und ein Stapel bleibt für die Dauer des Programms bestehen. Außerdem entfernt kein Operator (außer @) Werte aus dem Stapel. Stapeländerungen wirken sich jedoch nur auf den Block aus, in dem sie auftreten.

Werteauswahl

• a durch z

  Nimm den 0-25ten Gegenstand vom Stapel und lege ihn auf den Stapel. abezieht sich auf den Kopf oder das zuletzt geschobene Objekt des Stapels.

• A durch Z

  Holen Sie sich das 0-25ste Element des aktuellen Frames und schieben Sie es auf den Stapel.

• [

  Öffnen Sie einen "Rahmen", um Elemente aus der Stapelreferenz (siehe unten) auf dem Stapelkopf auszuwählen. [erfordert keine Übereinstimmung ], aber Frames haben einen lexikalischen Gültigkeitsbereich. In BlockScript wird "scope" durch geschweifte Klammern ( {... }) bestimmt, die Blöcke bilden. Daher hat das Öffnen eines Frames innerhalb eines Blocks keine Auswirkung auf den Code außerhalb des Blocks.

• ]

  Schließen Sie das aktuelle Bild und kehren Sie zum vorherigen Bild zurück (falls vorhanden).

Blöcke

• { ... }

  Erstellen Sie einen "Block" und legen Sie ihn auf den Stapel. Innerhalb eines Blocks beginnt der Stapel an der Stelle, an der er sich vor dem Block befand, mit der Ausnahme, dass der Stapel des Aufrufers nach oben verschoben wird. Stacks sind in BlockScript persistent und unveränderlich, sodass Blöcke Closures sind. Die Redewendung {[bedeutet, einen Block zu öffnen und dann einen Rahmen zu öffnen, um mit der Auswahl der Argumente zu beginnen (Verwendung von Athrough Z). Der Rückgabewert eines Blocks ist der Kopf des Stapels, wenn er }erreicht ist.

  Beispiel:

  '3 '2 '1 {[ b. d. f. B. C. D. A! } 'D 'C 'B d!;
  

  Dies wird gedruckt 123BCD123DCB123BCD123DCB…. Die Kleinbuchstaben beziehen sich auf Stapelwerte, während sich die Großbuchstaben auf Argumente beziehen (da der Frame auf den Stapel des Aufrufers festgelegt ist). A!Nimmt den Kopf des Aufrufers (der garantiert der aufgerufene Block ist) und ruft ihn auf. Wenn Sie sich fragen, warum es sich BCDjedes Mal umkehrt , müssen Sie B. C. D.diese Argumente in umgekehrter Reihenfolge eingeben, bevor der Block sich selbst aufruft.

• !

  Rufen Sie einen Block auf. Schieben Sie den Rückgabewert auf den Stapel.

Stapelreferenzen

• &

  Erstellen Sie eine Stapelreferenz und verschieben Sie sie in den Stapel. Stellen Sie sich dies als "Super-Nachteile" vor, da es effektiv jeden Gegenstand auf dem Stapel aufnimmt und daraus ein "Tupel" bildet. Die Redewendung &[bedeutet das, was auch immera , b, cgenannt , bevor sie kann nun mit zugegriffen werden A, B, C(für den Rest des Blockes oder bis ]festgestellt wird).

  Zum Teil, weil &mehr Werte erfasst werden, als normalerweise benötigt werden, verliert BlockScript von Entwurf an Speicher.

• @

  Wechseln Sie zu dem Stapel, auf den die Stapelreferenz zeigt a . Dieser Operator ist ziemlich seltsam, aber der BlockScript-Selbstinterpreter verwendet ihn ein paarmal, um zu vermeiden, dass dieselben Argumente zweimal übergeben werden müssen. Die Auswirkungen @(oder im Übrigen jede Stapeloperation) sind auf den Block beschränkt, in dem sie aufgerufen werden. Außerdem bleibt der Frame davon unberührt @, sodass Sie mit dem Frame die Werte erfassen können, die Sie nach dem Umschalten der Stapel benötigen.

Bedingter Ausdruck

• ? <on true> : <on false>

  Bedingter Ausdruck, genau wie der ternäre Operator in C. Das heißt, wenn a"wahr" ist (dh nicht gleich der ganzen Zahl Null ist), dann mache <on wahr> , andernfalls mache <auf falsch> .

I / O

Hinweis: Die Ein- und Ausgabe erfolgt in UTF-8. Ein "Zeichen" ist eine Ganzzahl, die einem Unicode-Index entspricht.

• ,

  Holen Sie sich das nächste Zeichen der Eingabe und schieben Sie es auf den Stapel. Wenn das Ende der Eingabe erreicht ist, drücken Sie stattdessen -1.

• .

  Geben Sie das Zeichen auf dem Kopf des Stapels aus.

Ganzzahl- / Zeichenliterale

Hinweis: Ganzzahlen und Zeichen sind in BlockScript identisch.

• 'c

  Drücken Sie den Buchstaben c.

• [0-9] +

  Geben Sie eine Dezimalzahl ein.

Arithmetik

Diese Operatoren arbeiten nur mit ganzzahligen Werten.

• +Berechnen Sie b+a (drücke das Ergebnis, aber verwerfe keinen der beiden Werte).
• -Berechnen b-a .
• *Berechnen b*a .
• /Rechnen b/a (ganzzahlige Division; rundet gegen negative Unendlichkeit).
• %Berechnen Sie b% a(ganzzahliger Modul; rundet gegen negative Unendlichkeit).

Vergleichsoperatoren

Diese Operatoren arbeiten nur mit ganzzahligen Werten.

• <Wenn bkleiner ist als a, drücke 1, sonst drücke 0.
• >
• =

Sonstiges

• # Kommentar zum Zeilenende
• Das Programm muss mit enden ;
• Alle anderen Zeichen werden ignoriert.

Zozotez LISP : 414

Zeilenumbrüche, die hinzugefügt werden, um einen netten Block zu erhalten, werden nicht benötigt und nicht gezählt.

((\(E V A L)(E(r)'(())))(\(x e)(?(s x)(V x e)((\(b j)(?(= b ")(a j)(?(= b \)x
(?(= b ?)(?(E(a j)e)(E(a(d j))e)(E(a(d(d j)))e))(?(s b)(A b(E(a j)e)(E(a(d j)
)e))(E(a(d(d b)))(L(a(d b))j e)))))))(E(a x)e)(d x))))(\(x g)(? g(?(= x(a(a
g)))(d(a g))(V x(d g)))x))(\(f h v)(?(= f r)(r)(?(= f p)(p h)(?(= f s)(s h)(?
(= f a)(a h)(?(= f d)(d h)(?(= f =)(= h v)(c h v))))))))(\(k v i)(? k(L(d k)(
d v)(c(c(a k)(E(a v)i))i))i)))

Theoretisch sollte es in der Lage sein, sich selbst auszuführen, aber da der ursprüngliche Interpreter eine BrainFuck- Binärdatei und selbst ein Interpreter ist, konnte ich nur jeden Teil testen. Wenn (p p)ich es mir selbst und einem einfachen Ausdruck gebe, denke ich, dass es mehr Zeit braucht als die 40 Minuten, auf die ich bisher gewartet habe, und ich benutze mein Fasten jitbf, um es auszuführen, was (falsch) Perl Inline-C verwendet, um C-Code im laufenden Betrieb auszuführen.

Es ist unmöglich, das gesamte Zozotez in Zozotez zu implementieren, da es keine Mittel zum :Mutieren der Nachteile enthält und (setq / define) diese benötigt, um die Bindungen zu aktualisieren. Ich habe auch kein explizites begin / progn- oder & rest-Argument, keine Makros und keine speziellen Druckargumente implementiert, da ich es nicht im Interpreter verwendet habe. Ich habe p(print) mit einbezogen, obwohl ich es nicht benutze, daher müssen Programme ihre Berechnungen genau wie der ursprüngliche Interpreter explizit ausgeben.

Das gleiche ungolfed:

;; A stand alone Zozotez script need to be
;; contained in one expression, here with
;; all functions provided as arguments to
;; get them bound in the dynamic environment
((\ (E V A L)
  (E(r)'(())))
 ;; E (EVAL)
 (\ (x e)
   (? (s x)
      (V x e)
      ((\ (b j)
         (? (= b ") (a j)
         (? (= b \) x
         (? (= b ?) (? (E(a j)e) (E(a(d j))e) (E(a(d(d j)))e))
         (? (s b)
            (A b (E(a j)e) (E (a(d j))e))
            (E (a(d(d b))) (L(a(d b))j e)))))))
       (E (a x) e)(d x))))
 ;; V (VALUE / symbol->value)
 (\ (x g)
   (? g
      (? (= x (a (a g)))
         (d (a g))
         (V x (d g)))
      x))
 ;; A (APPLY) but just for primitives
 (\ (f h v)
   (? (= f r) (r)
   (? (= f p) (p h)
   (? (= f s) (s h)
   (? (= f a) (a h)
   (? (= f d) (d h)
   (? (= f =)
      (= h v)
      (c h v))))))))
 ;; L ( joint evLis / extend-env)
 (\ (k v i)
   (? k
      (L (d k) 
         (d v)
     (c (c (a k) 
           (E (a v) i)) 
        i))
      i)))

CHIQRSX9 + (wahrscheinlich nicht konkurrierend), 2 Bytes

+I

In dieser HQ9 + -basierten Sprache ist es nicht möglich, einen selbstübersetzenden Interpreter zu schreiben, ohne Ieinen integrierten Interpreter zu verwenden, der STDIN verarbeitet.

Concurrent Filesystem Befunge 98 - 53 \ 18 Bytes (mit ziemlicher Sicherheit Betrug)

Voller 53-Byte-Interpreter ohne Einschränkungen (obwohl ich keine komplizierten Timing-Interaktionen getestet habe, die IP-Splitting und Wrapping beinhalten):

v ;;;;;;;;
>]390'ai@
 t;;;;;;;;
;>zzzzz#;

Liest Eingaben aus einer Datei mit dem Namen aund führt sie aus. In den Regeln ist nicht festgelegt, dass wir keinen selbstmodifizierenden Code verwenden können.

18-Byte-Interpreter, der kein Wrapping zulässt (die IP-Adresse wird an einer Kante des Codes verschoben und beginnt an der gegenüberliegenden Kante):

]210'ai@
t
><