(Inspiriert von diesem Kommentar zu einer alten Frage.)

Hintergrund

Ein Fehlerquine (auch als "Kimian-Quine" bezeichnet) ist ein Programm, das beim Kompilieren oder Ausführen bewirkt, dass der Compiler / Interpreter / die Laufzeit eine Fehlermeldung druckt, die identischen Text wie das Programm selbst enthält, und sonst nichts. Für die Zwecke dieser Herausforderung definieren wir "Fehler" allgemein, um auch Warnungen einzuschließen.

Aufgabe

Bei dieser Herausforderung suchen wir nach einem Quine, der auch ein Fehlerquine ist. Bei der Ausführung muss das Programm seinen eigenen Quellcode normal drucken (dh nicht als Fehler- / Warnmeldung). Dies muss eine richtige Quine sein (dh ein Teil des Programms muss einen anderen Teil der Ausgabe codieren). Darüber hinaus muss das Kompilieren und Ausführen des Programms dazu führen, dass der Quellcode des Programms - und sonst nichts - von der Implementierung als Fehler- oder Warnmeldung gedruckt wird. (Beachten Sie, dass dies bedeutet, dass Sie keine Fehler zur Kompilierungszeit in Sprachen verwenden können, in denen die normale Ausführung des Programms verhindert wird.) Mit anderen Worten, der Quellcode des Programms wird zweimal gedruckt, einmal über jede Methode.

Klarstellungen

• In den meisten Fällen ist es offensichtlich, was eine Fehler- / Warnmeldung ist und was nicht. Wir unterscheiden hier nicht zwischen den beiden. Definieren Sie in mehrdeutigen Fällen eine Fehler- / Warnmeldung als jeden Text, der von der Implementierung ausgegeben wird, entweder: 1. als Folge von etwas anderem als der Ausführung eines Befehls (oder was auch immer das nächste Äquivalent in der Sprache ist); oder 2. das war nicht Teil der Eingabe in den Befehl, der es als Ausgabe erzeugt hat.
• Der Fehler- / Warnungsteil des Quines muss kein richtiges Quine sein (obwohl dies in den meisten Fällen zufällig ist, da die meisten Fehler- und Warnmeldungen erhebliche Mengen an festem Text enthalten).
• Es ist akzeptabel, dass das Programm mehrere Fehler / Warnungen ausgibt, die die Quelle des Programms bilden, wenn sie miteinander verkettet werden. Es ist nicht akzeptabel, Fehler / Warnungen auszugeben, die nicht in der Quelle erscheinen.
• Anders als bei vielen anderen Herausforderungen sind die dem Compiler zugewiesenen Schalter und der Programmdateiname bei dieser Herausforderung wahrscheinlich von hoher Relevanz. Da die Herausforderung sonst möglicherweise nicht möglich ist, bin ich bereit, hier flexibel zu sein. Wenn Sie die Implementierung jedoch auf ungewöhnliche Weise ausführen, denken Sie daran, dass die PPCG-Regeln dafür eine Byte-Strafe erheben (entsprechend der Anzahl der zusätzlichen Zeichen, die Sie müssten in der Befehlszeile über die kürzeste "normale" Art und Weise, ein Programm auszuführen, hinzufügen. Daher müssen Sie die Größe der Strafe in Ihrem Beitrag angeben. (Wenn beispielsweise der von Ihnen verwendete Interpreter das Programm aus einer Datei liest und keine besonderen Einschränkungen für den Dateinamen aufweist, ist die kürzeste normale Methode zum Ausführen des Programms eine Datei mit einem 1-stelligen Dateinamen.
• Die von Ihnen verwendete Compiler- / Interpreter-Version kann durchaus relevant sein. Geben Sie daher im Rahmen Ihrer Einreichung einen bestimmten Compiler oder Interpreter an, auf dem Ihr Programm funktioniert und welche Version erforderlich ist. (Beispielsweise könnte eine C-Übermittlung im Header "C (gcc 6.2.0)" angeben.)
• Beachten Sie, dass diese Aufgabe möglicherweise nicht in allen Sprachen möglich ist. In den Sprachen, in denen dies der Fall ist, besteht die einfachste Methode wahrscheinlich darin, eine Fehler- oder Warnmeldung zu finden, für die eine Teilmenge des Textes angepasst werden kann (durch Ändern des Namens von etwas, das in der Nachricht zitiert wird; Dateinamen sind eine häufige Wahl hier, aber nicht der einzige). Ich bin besonders beeindruckt (und überrascht), wenn jemand einen Weg findet, dies nur mit Fehler- und Warnmeldungen zu tun, deren Text korrigiert ist.

Siegbedingung

Dies ist eine Code-Golf- Herausforderung, daher wird ein Eintrag als besser angesehen, wenn er eine kleinere Byteanzahl hat. Sobald Ihr Programm überhaupt funktioniert, möchten Sie es optimieren, um die Anzahl der Bytes so weit wie möglich zu verringern. (Lassen Sie sich jedoch nicht entmutigen, wenn es bereits einen kürzeren Eintrag gibt, insbesondere wenn er in einer anderen Sprache verfasst ist. Wir suchen hier wirklich danach, einen bestimmten Algorithmus oder eine bestimmte Idee hinter einem Programm so weit wie möglich zu verkürzen, aber mehrere zu sehen Lösungen in verschiedenen Sprachen oder die auf unterschiedlichen Prinzipien beruhen, lohnen sich immer.)

JavaScript (Firefox 50), 153 Byte

Error: "Error: 1.replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x.slice(7)})".replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x.slice(7)})

Erläuterung

Die Idee hier war, mit dem am einfachsten zu modifizierenden JS-Quine zu beginnen, das ich bisher gefunden habe:

".replace(/.+/,x=>alert(uneval(x)+x))".replace(/.+/,x=>alert(uneval(x)+x))

Das throwSchlüsselwort ist eine einfache Möglichkeit, einen eigenen Code zu erstellen:

".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})

Es gibt jedoch ein kleines Problem: Firefox stellt die ausgelöste Nachricht mit voran Error:. Zum Glück Error: mycodeist tatsächlich JavaScript gültig! (Um mehr darüber zu erfahren, besuchen Sie MDN .)

Error: ".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})Error: ".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})

Ups, das warnt das Falsche:

".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})Error: ".replace(/.+/,x=>{alert(x=uneval(x)+x);throw x})Error: 

Da das Anführungszeichen nicht mehr am Anfang des Codes steht, erhalten uneval(x)+xwir nicht das richtige Ergebnis. Der beste Weg, dies zu beheben, besteht darin, anstelle der verschachtelten Zeichenfolge einen Platzhalter hinzuzufügen:

Error: "Error: 1.replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x})".replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x})

Oh, jetzt gibt es ein Extra Error:in der Fehlermeldung. Lassen Sie uns das beheben, indem Sie die Zeichenfolge in Scheiben schneiden:

Error: "Error: 1.replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x.slice(7)})".replace(/.+/,x=>{alert(x=x.replace(1,uneval(x)));throw x.slice(7)})

Und schließlich sind sowohl die Ausgabe als auch die Fehlermeldung mit dem Code identisch! Ich würde ein Stack-Snippet hinzufügen, aber es scheint in keinem Browser in einem Snippet zu funktionieren.

Python 2, 217 80 51 Bytes

Der nachlaufende Zeilenvorschub ist erforderlich.

s='s=%r;print s%%s;exit(s%%s)';print s%s;exit(s%s)

Probieren Sie es online aus

Ich begann mit einer einfachen Quine:

s='s=%r;print s%%s';print s%s

Dann habe ich raiseam Ende hinzugefügt , um eine zu werfen IOError.

s='s=%r;print s%%s;raise IOError(s%%s)';print s%s;raise IOError(s%s)

Leider verursachte der Traceback Probleme (ich konnte ihn nicht vollständig entfernen lassen), und der Name der Ausnahme wurde immer wie vorgedruckt IOError: <code here>, auch wenn ich den Traceback entfernt habe.

Dann fand ich diese hilfreiche SO-Antwort und modifizierte sie für meine Zwecke.

Dann stellte ich fest, dass ich das Erstellen meiner eigenen Klasse überspringen und nur verwenden kann sys.exit, wodurch mein Code viel kürzer wird.