(Inspiré par ce commentaire sur une vieille question.)

Contexte

Un quine d'erreur (également connu sous le nom de "quine Kimian") est un programme qui, une fois compilé ou exécuté, fait que le compilateur / interprète / runtime imprime un message d'erreur dont le texte est identique au programme lui-même, et rien d'autre. Aux fins de ce défi, nous définissons le terme "erreur" au sens large, pour inclure également les avertissements.

Tâche

Dans ce défi, nous recherchons un quine qui est également un quine d'erreur. Une fois exécuté, le programme doit imprimer son propre code source normalement (c'est-à-dire pas comme un message d'erreur / d'avertissement); cela doit être une quine appropriée (c'est-à-dire qu'une partie du programme doit coder une partie différente de la sortie). En outre, la compilation et l'exécution du programme doivent également entraîner l'impression du code source du programme - et rien d'autre - en tant que messages d'erreur ou d'avertissement par l'implémentation. (Notez que cela signifie que vous ne pourrez pas utiliser les erreurs de compilation, dans les langues où celles-ci empêchent le programme de s'exécuter normalement.) En d'autres termes, le code source du programme sera imprimé deux fois, une fois via chaque méthode.

Clarifications

• Dans la plupart des cas, ce sera et ne sera pas un message d'erreur / d'avertissement évident; nous ne faisons pas de distinction entre les deux ici. Dans les cas ambigus, définissez un message d'erreur / d'avertissement comme n'importe quel texte généré par l'implémentation: 1. à la suite de quelque chose d'autre que l'exécution d'une commande (ou quel que soit l'équivalent le plus proche dans le langage); ou 2. qui ne faisait pas partie de l'entrée de la commande qui l'a produite en sortie.
• La partie erreur / avertissement du quine n'a pas besoin d'être un quine approprié (bien que dans la plupart des cas, ce sera par hasard, car la plupart des messages d'erreur et d'avertissement contiennent des quantités considérables de texte fixe).
• Il est acceptable que le programme génère plusieurs erreurs / avertissements, qui constituent la source du programme lorsqu'ils sont concaténés ensemble. Il n'est pas acceptable de générer des erreurs / avertissements qui n'apparaissent pas dans la source.
• Contrairement à de nombreux défis, les commutateurs donnés au compilateur et le nom de fichier du programme sont susceptibles d'être très pertinents dans ce défi. Étant donné que le défi peut ne pas être possible autrement, je suis prêt à être flexible ici, bien que si vous exécutez l'implémentation d'une manière inhabituelle, n'oubliez pas que les règles PPCG facturent une pénalité d'octet pour le faire (égale au nombre de caractères supplémentaires qui vous devrez ajouter sur la ligne de commande la manière la plus courte "normale" d'exécuter un programme), et vous devrez donc spécifier la taille de la pénalité dans votre message. (Par exemple, si l'interpréteur que vous utilisez lit le programme dans un fichier et n'a pas de restrictions particulières sur le nom de fichier, la manière normale la plus courte d'exécuter le programme serait à partir d'un fichier avec un nom de fichier à 1 caractère; ainsi,
• La version du compilateur / interprète que vous utilisez peut être pertinente, donc dans le cadre de votre soumission, veuillez indiquer un compilateur ou un interprète spécifique sur lequel votre programme fonctionne et quelle version est requise. (Par exemple, une soumission C peut indiquer "C (gcc 6.2.0)" dans l'en-tête.)
• Notez que cette tâche peut ne pas être possible dans toutes les langues. Dans les langues où il se trouve, la méthode la plus simple sera probablement de trouver un message d'erreur ou d'avertissement pour lequel il est possible de personnaliser un sous-ensemble du texte (en changeant le nom de quelque chose qui est cité dans le message; les noms de fichiers sont un choix courant ici, mais pas le seul). Je serai particulièrement impressionné (et surpris) si quelqu'un trouve un moyen de le faire en utilisant uniquement des messages d'erreur et d'avertissement dont le texte est corrigé.

Condition de victoire

Il s'agit d'un défi de code-golf , donc une entrée est considérée comme meilleure si son nombre d'octets est plus petit. En tant que tel, une fois que votre programme fonctionne, vous voulez l'optimiser pour réduire le nombre d'octets autant que possible. (Cependant, ne vous découragez pas s'il y a déjà une entrée plus courte, surtout si elle est dans une langue différente; ce que nous recherchons vraiment ici est de raccourcir autant que possible un algorithme ou une idée particulier derrière un programme, mais en voyant plusieurs des solutions dans différentes langues ou qui reposent sur des principes différents valent toujours la peine.)

JavaScript (Firefox 50), 153 octets

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)})

Explication

L'idée ici était de commencer par le quine JS le plus facilement modifiable que j'ai trouvé à ce jour:

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

Le throwmot-clé est aussi un moyen simple de lui faire lancer son propre code:

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

Cependant, il y a un léger problème: Firefox ajoute le message lancé avec Error:. Heureusement, Error: mycodec'est en fait du JavaScript valide! (Pour en savoir plus à ce sujet, visitez MDN .)

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

Oups, cela signale la mauvaise chose:

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

Puisque le guillemet n'est plus au début du code, uneval(x)+xne nous donnera pas le résultat correct. La meilleure façon de résoudre ce problème consiste à ajouter un espace réservé à la place de la chaîne imbriquée:

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})

Uh-oh, maintenant il y a un extra Error:dans le message d'erreur. Corrigeons cela en coupant la chaîne:

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)})

Et enfin, la sortie et le message d'erreur sont identiques au code! J'ajouterais un extrait de pile, mais il ne semble pas fonctionner dans un extrait dans un navigateur.

Python 2, 217 80 51 octets

Le saut de ligne arrière est requis.

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

Essayez-le en ligne

J'ai commencé avec une simple quine:

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

Ensuite, j'ai ajouté raiseà la fin pour lancer un IOError.

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

Malheureusement, le retraçage causait des problèmes (je ne pouvais pas le faire disparaître complètement), et le nom de l'exception était toujours imprimé devant comme IOError: <code here>, même si je supprimais le traçage.

Ensuite, j'ai trouvé cette réponse SO utile et l'ai modifiée à mes fins.

Ensuite, j'ai découvert que je pouvais ignorer la création de ma propre classe et que je pouvais simplement l'utiliser sys.exit, ce qui rend mon code beaucoup plus court.