Essayez d’écrire du code dans votre langue et faites en sorte qu’il ne réponde plus à notre critère de langage de programmation .

Un langage répond à nos critères (version simplifiée pour ce défi) d’être un langage de programmation si:

• Il peut lire les entrées utilisateur représentant des nuplets d’entiers positifs d’une certaine manière.
• Il peut générer au moins deux résultats possibles différents en fonction de l'entrée.
• Il peut prendre deux entiers positifs et les ajouter (et le résultat peut affecter la sortie).
• Il peut prendre un entier positif et décider s’il s’agit d’un nombre premier (et le résultat peut affecter la sortie).
• Aux fins de ce défi, tout type de sortie qui n'est pas une méthode de sortie autorisée pour un défi normal est ignoré. Donc, peu importe que le programme puisse aussi jouer un morceau de musique, ou poster via HTTP, etc.
• Mise à jour: vous pouvez également choisir une ou plusieurs des méthodes de sortie autorisées et ignorer toutes les autres. Mais vous devez utiliser la même définition partout dans les critères suivants. Et si votre programme peut désactiver plusieurs méthodes de sortie, cela vaut plus de votes positifs.

Des exemples tels que le rendre impossible à sortir ou la désactivation de toutes les constructions de boucle afin qu'il ne puisse pas effectuer de test de primalité et s'assurer que l'utilisateur ne peut pas les réactiver.

Vous devriez laisser une place pour insérer un nouveau code. Par défaut, c'est à la fin de votre code. Si nous envisageons de placer le code source à cet endroit dans votre réponse et d'exécuter le code complet en tant que programme complet interprétant une nouvelle langue, cette langue ne devrait pas satisfaire aux critères.

Mais le code inséré doit être exécuté comme un langage répondant aux critères:

• Le code inséré doit être grammaticalement identique à quelque chose (disons qu'il s'agit d'un bloc de code dans les critères suivants) qui satisfait généralement les critères, du point de vue de quiconque veut écrire un surligneur de syntaxe. Donc, cela ne peut pas être dans une chaîne, un commentaire, etc.
• Le code inséré doit être réellement exécuté, de manière à répondre aux critères. Donc, cela ne peut pas être dans une fonction non utilisée ou sizeofen C, vous ne pouvez pas exécuter seulement une partie non fonctionnelle du code, et vous ne pouvez pas la mettre après une boucle infinie, etc.
• Vous ne pouvez pas limiter le nombre de programmes grammaticalement corrects générés de cette manière. S'il existe déjà quelque chose comme une limite de longueur dans la langue que vous utilisez, cela ne devrait pas satisfaire aux critères même si cette limite est supprimée.
• Vous ne pouvez pas modifier ou "utiliser" le contenu des entrées / sorties, mais vous pouvez empêcher leur accès.
• Ces critères ne s'appliquent généralement qu'aux langues sans I / O explicite:
  • Votre code doit rediriger la saisie de l'utilisateur (qui contient des informations de longueur arbitraire) vers le code inséré, si un bloc de code n'est généralement pas en mesure d'obtenir la saisie de l'utilisateur directement / explicitement dans la langue que vous utilisez.
  • Votre code doit imprimer la valeur renvoyée du code inséré, si un bloc de code n'est généralement pas en mesure de produire des éléments directement / explicitement dans la langue que vous utilisez.
  • Si vous imprimez la valeur renvoyée et que celle-ci est saisie dans la langue que vous utilisez, le type renvoyé devrait pouvoir avoir 2 valeurs pratiquement possibles. Par exemple, vous ne pouvez pas utiliser le type struct {}ou struct {private:int x;}en C ++.

C'est un concours de popularité. La réponse valide la plus votée (personne n'a donc repéré une erreur ou toutes les erreurs sont corrigées) gagne.

Des clarifications

• Vous ne devez pas modifier le code dans le formulaire texte, mais vous pouvez modifier la syntaxe avant que le code ne soit interprété ou compilé.
• Vous pouvez faire d'autres choses pendant que le code est en cours d'exécution. Mais la raison pour laquelle il ne répond pas aux critères devrait être dans le code inséré lui-même. Cela peut provoquer des erreurs à cause de l'interférence d'un autre thread, mais pas seulement être tué par un autre thread.
• Toutes les spécifications signifient fondamentalement qu'il devrait être grammaticalement conforme aux critères si toutes les fonctions intégrées ne sont pas modifiées mais ne le sont pas réellement. C'est bien si vous trouvez des solutions de contournement non grammaticales, telles que le fait de transmettre correctement les paramètres au bloc de code, mais ne les utilisez pas d'une manière ou d'une autre.
• Encore une fois, le code inséré doit être réellement exécuté. Le code après une boucle infinie ou un crash est considéré comme "non réellement exécuté", donc non valide . Ces réponses pourraient être intéressantes, mais il existe déjà une autre boucle infinie ou des questions bloquantes sur ce site, et vous en trouverez peut-être une plus appropriée. Sinon, envisagez de poser une nouvelle question. Voici des exemples de ces questions:
  • La boucle infinie la plus courte ne produit aucune sortie
  • Pourquoi ça ne se termine pas?
  • Boucle sans 'boucle'
  • Défi: écrire un morceau de code qui se ferme tout seul
  • Erreurs d'exécution ridicules
  • Crash votre compilateur préféré

Classement

var QUESTION_ID=61115/*,OVERRIDE_USER=8478*/;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,/*getComments()*/(more_answers?getAnswers():process())}})}/*function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}*/function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),score:s.score,language:a[1],lang:jQuery('<div>').html(a[1]).text(),link:s.share_link})}),e.sort(function(e,s){var r=e.score,a=s.score;return a-r});var s={},r=1,a=null,n=1;e.forEach(function(e){e.score!=a&&(n=r),a=e.score,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",e.n=n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.score).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text())/*,s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}*/});var t=e/*[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o])*/;t.sort(function(e,s){return (e.lang.toUpperCase()>s.lang.toUpperCase())-(e.lang.toUpperCase()<s.lang.toUpperCase())||(e.lang>s.lang)-(e.lang<s.lang)});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{PLACE}}",o.n).replace("{{LANGUAGE}}",o.language).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.score).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<(?:h\d|(?!.*<h\d>)p)>\s*((?:[^,;(\s]| +[^-,;(\s])+)(?=(?: *(?:[,;(]| -).*?)?\s*<\/(h\d|p)>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;float:left}table{width:250px}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Score</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Sorted by Language</h2> <table class="language-list"> <thead> <tr><td></td><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{PLACE}}</td><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

JavaScript shell

Cela rendra la langue complètement inutilisable.

clear(this);

N'est-ce pas gentil de voir que JavaScript a une telle fonction pour se détruire?

C'est assez simple, la clearfonction vide complètement un objet. thisfait référence à l'objet global qui efface tout, y compris les constructeurs et les fonctions.

Parce que cela efface tout , faire quoi que ce soit , même de définir un littéral jetteront une erreur, ce qui rend la langue complètement inutile: _{* environnement REPL pas nécessaire. Utilise le moteur SpiderMonkey (shell non navigateur), le moteur JS d'origine.}

Emmental

;#33!

Je sais que ce n'est pas du code golf, mais le bon outil pour le travail, vous savez ...

Le code de l'utilisateur peut être inséré après le !.

L'Emmental est un esolang intéressant basé sur la réécriture de l'interprète. Chaque symbole (y compris ceux intégrés) peut être redéfini comme un programme Emmental arbitraire. Le langage repose tellement sur cette fonctionnalité qu'elle ne fournit aucune construction en boucle. Au lieu de cela, vous définissez des commandes récursives qui apparaissent dans leurs propres définitions.

Cette redéfinition se produit via !, qui lit un caractère de la pile, puis lit une chaîne de la pile jusqu'à ce qu'il rencontre un ;. Le caractère est ensuite redéfini pour désigner le programme représenté par cette chaîne.

Cela signifie que nous pouvons désactiver les fonctions de boucle d’Emmental en se redéfinissant ! en tant que programme vide. Bien que tous les autres codes de l'Emmental fonctionnent encore parfaitement et que bon nombre des critères d'un langage de programmation soient toujours remplis, il est impossible de redéfinir d'autres symboles. Sans cette fonctionnalité (et donc sans pouvoir boucler), Emmental ne peut plus vérifier si un nombre est premier.

PHP

On peut complètement tuer PHP en fixant la limite de mémoire à 1.

Il mourra complètement.

Essaye ça:

<?php
    ini_set('memory_limit',1);

    //code here

Cela ne devrait même pas générer d'erreur, car il n'y a pas assez de mémoire pour cela.

Vous pouvez en savoir plus sur la memory_limitdirective

Si le précédent est invalide, on peut utiliser des tampons de sortie:

<?php
    ob_start();

    //code here

    ob_clear();

Cela supprime complètement toute sortie. Étant donné que le tampon de sortie est toujours ouvert, certaines autres choses laissées accidentellement après le code ne seront pas affichées.

En utilisant l’idée de @fschmengler :

<?php
    define('OB_START_LEVEL', ob_get_level());
    ob_start(function(){return'';}, -1, PHP_OUTPUT_HANDLER_CLEANABLE);
    //or, for PHP <5.3:
    //ob_start(create_function('','return"";'), -1, PHP_OUTPUT_HANDLER_CLEANABLE);

    //code here

    while(ob_get_level() > OB_START_LEVEL) ob_clear();

Cela évitera le problème de suppression du tampon de sortie démarré automatiquement, utilisé pour intercepter la sortie à compresser.

Cela évite également que le tampon de sortie ne soit supprimé ou vidé (envoyé au navigateur). Pour ré-imposer cela, un gestionnaire de sortie est ajouté, qui renvoie toujours une chaîne vide.
Courir ob_end_flush(); echo "Hello, world!";ne produira rien, mais enverrait la sortie en clair ob_start();.

Merci à @LucasTrzesniewski pour avoir exposé ce problème!

Code machine x86 en mode réel (=> presque tous les programmes DOS)

00000000  6a 00 07 b9 00 04 30 c0  31 ff f3 aa              |j.....0.1...|
0000000c

c'est à dire

push 0
pop es
mov cx,400h
xor al,al
xor di,di
rep stosb

J'espère que vous n'étiez pas trop attaché à votre table d'interruption.

Java

import java.io.*;
import java.lang.reflect.*;
public class Test2 {
    public static void main(String[] args) throws Exception {
        args = new String[0];
        System.setOut(new PrintStream(new ByteArrayOutputStream()));
        System.setErr(new PrintStream(new ByteArrayOutputStream()));
        System.setIn(new ByteArrayInputStream(new byte[0]));

        Field modifiersField = Field.class.getDeclaredField("modifiers");
        modifiersField.setAccessible(true);

        Class<?> fdClass = java.io.FileDescriptor.class;
        Field outField = fdClass.getDeclaredField("out");
        outField.setAccessible(true);
        modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
        outField.set(null, new FileDescriptor());
        Field errField = fdClass.getDeclaredField("err");
        errField.setAccessible(true);
        modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
        errField.set(null, new FileDescriptor());
        Field inField = fdClass.getDeclaredField("in");
        inField.setAccessible(true);
        modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);
        inField.set(null, new FileDescriptor());

        System.setSecurityManager(new SecurityManager(){
            private boolean exitAllowed = false;
            public void checkPermission(java.security.Permission perm) {
                String name = perm.getName();
                if(name.equals("setIO")
                        || name.equals("setSecurityManager")
                        || name.equals("writeFileDescriptor")
                        || name.equals("readFileDescriptor")
                        || name.equals("suppressAccessChecks")
                        || (perm instanceof FilePermission
                            && name.startsWith("/proc/self/fd/"))){
                    throw new SecurityException("Nope");
                }
                if(name.startsWith("exitVM") && !exitAllowed){
                    exitAllowed = true;
                    System.exit(0);
                }
            }
            public void checkExec(String cmd){
                throw new SecurityException("nope");
            }
        });

        // program here
    }
}

Edit: les contre-mesures font de ce géant :(

Redirige stdin et stdout vers des flux null et remplace les arguments par un tableau vide. Utilise également d’énormes quantités de piratages de réflexion pour s’assurer que l’IO standard est réellement caché. Enfin, il définit un gestionnaire de sécurité pour s'assurer que l'IO standard ne peut pas être recréé, ce qui empêche les programmes de définir le code de sortie.

Lua

_ENV=""

En Lua, _ENVest l’environnement dans lequel toutes les variables globales, fonctions, tables, etc. sont stockés. Défini comme chaîne vide, vous ne pouvez rien définir de nouveau et toutes les fonctions et variables sont effacées. Cela signifie que vous ne pouvez rien produire, prendre en entrée ou presque rien faire.

Langage de programmation Shakespeare

Have Fun Mr Parser.

Romeo, a young man of Verona.
Juliet, a young lady of Verona.
Hamlet, another character which causes the crash.

Act I
Scene I The crash.

[Enter Romeo]
[Enter Juliet]
[Exit Hamlet]

Dans SPL, l'analyseur intégré téléchargé avec le programme suit des règles très spécifiques concernant ce qui peut se produire dans le script. L'une de ces règles est que seuls deux personnages peuvent être sur scène à la fois. De plus, faire sortir un personnage de la scène qui n’a jamais été sur scène le confondra. Il en va de même pour l'ajout d'un personnage à la scène qui est déjà sur scène. Lorsque l'analyseur reçoit une erreur, il refusera de FAIRE TOUT autre chose; vous devez littéralement arrêter complètement le programme et l'analyseur, puis tout redémarrer.

PS Si vous ne savez pas comment cette langue fonctionne, cherchez-la sur Google. C'est génial.

Petite conversation

Je ne suis pas sûr que cela soit admissible:

Smalltalk := Nil.

Cela supprime tout l'environnement d'exécution en suspendant le moteur d'objet. Le seul moyen de résoudre ce problème consiste à forcer la fin du processus et à redémarrer à partir de la sauvegarde.

Pour ceux qui ne le savent pas, le fonctionnement de [Visual Works] Smalltalk est légèrement étrange. C'est comme un mini-OS. Lorsque vous démarrez Smalltalk, vous chargez une "image de mémoire" dans la RAM et il continue de s'exécuter là où il s'était arrêté. L'ensemble de l'EDI Smalltalk est écrit en Smalltalk et est modifiable de manière dynamique.

En particulier, Smalltalkest un dictionnaire contenant toutes les variables globales. Plus particulièrement, chaque fois que vous déclarez une nouvelle classe, une variable globale portant ce nom est créée, pointant vers l' Classobjet de votre nouvelle classe. Ainsi, la définition Smalltalkde Nil(essentiellement nul) supprime toutes les classes de l’ensemble du système. Même les gestionnaires d'événements de l'interface graphique vont poof.

Je n'ai aucune idée pourquoi cette variable est même accessible en écriture. Probablement parce que c'est une variable globale, et existe donc comme une entrée à l'intérieur de lui-même. (Avez-vous déjà mal à la tête? Ai-je déjà mentionné que chaque objet a une classe et que les classes sont des objets; chaque classe a donc une classe? La classe d'une classe s'appelle une métaclasse, mais une métaclasse est aussi un objet, qui a donc une classe...)

Vous pourriez probablement obtenir un effet similaire en effaçant le dictionnaire plutôt que de le remplacer par null. En effet, vous pouvez coder pour supprimer toutes les classes du système, ce qui vous empêche de faire quoi que ce soit. Mais puisque le compilateur Smalltalk est aussi une classe ... tout ce qui casse le langage casse aussi l’ensemble de l’IDE, alors ...

Haskell

Il y a deux possibilités ici.

Idée ennuyeuse n ° 1: Définir mainpour ne rien faire. Maintenant, quel que soit le code que vous écrivez, il ne pourra jamais être exécuté. (Sauf si vous l'exécutez manuellement à partir de la réplique.)

Idée ennuyeuse n ° 2: Définir un module sans exportation publique. Maintenant, peu importe le code que vous écrivez, il ne pourra jamais être exécuté.

Idée intéressante: Désactivez toutes les importations.

module Fubar where
import Prelude ()
foo = foo
-- More code here.

Maintenant , vous pouvez définir des fonctions qui sont visibles et peuvent être exécutés ... mais ils ne peuvent rien faire. Tous les types et fonctions Haskell standard sont maintenant masqués. (À l'exception de quelques éléments très liés à la langue.)

Plus particulièrement, vous ne pouvez effectuer aucune E / S. Vous ne pouvez pas non plus faire d'arithmétique de précision machine. (Depuis Int, Doubleetc ne sont plus définis.)

Vous pouvez toujours écrire des fonctions lambda-calcul qui effectuent des calculs réels. Vous ne pouvez pas obtenir de données dans ou hors de la chose. Mais vous pouvez bien sûr écrire un autre module séparé qui appelle le Fubarmodule ci-dessus et effectue des E / S en son nom (prouvant ainsi que le code s'exécute et fait des choses).

Quelques subtilités:

• La foo = foodéclaration fictive est nécessaire pour empêcher quiconque d'ajouter des importations supplémentaires. (Les importations ne peuvent pas apparaître après les déclarations.)

• Il existe différentes extensions de langage Haskell non standard qui vous permettraient de sortir de cette situation. Mais les extensions de langage doivent être activées avec un pragma de compilation en haut du fichier. (Ou avec un commutateur de ligne de commande pour le compilateur. Je ne peux pas vraiment empêcher cela!)

PostScript

Oui, PostScript est un langage de programmation. De plus, c'est un langage de programmation où toutes les constructions de langage sont des fonctions définies par le système, qui peuvent être redéfinies ...

1000 dict /Magic def
systemdict {pop Magic exch {} put} forall
Magic begin

En anglais:

• Créez un dictionnaire vide de 1 000 éléments et nommez-le Magic.
• Pour chaque clé systemdict, ajoutez la même clé à Magic, avec une définition vide (" {}").
• Appuyez Magicsur le haut de la pile de dictionnaires.

À partir de ce moment, chaque commande en langage PostScript est définie pour ne rien faire. Autant que je sache, il est impossible d'échapper à cette condition.

(Techniquement, vous ne "détruisez" pas les anciennes définitions, vous ne faites que les observer. Si vous pouviez quand même exécuter end, cela sortirait Magicde la pile de dictionnaires, effacerait toutes les commandes et vous redonnerait la vie. Mais depuis endlui-même est également ombragé ... il ne fera rien maintenant.)

Notez que toutes les commandes seront toujours exécutées ... c'est juste qu'elles sont maintenant définies pour ne rien faire. Vous n'obtiendrez aucune erreur, c'est que rien ne se passera. (Et bien, je suppose que le débordement de pile finira par arriver ...)

Tout programme s’exécutant sous Linux / x86 (-64)

Ce programme est écrit en C, mais il peut perturber l'exécution de tout programme exécuté sous Linux / x86 (-32 ou -64). Vous l'ajoutez à l'invocation de ligne du programme que vous souhaitez interrompre.

Il utilise l’API du débogueur pour empêcher le programme cible de produire une sortie. Plus précisément, tous les appels système pouvant communiquer avec le monde en dehors du processus (le plus évidemment write, bien sûr, mais aussi openlors de la création d'un fichier, la majeure partie de l'API de socket, killlorsqu'il est appliqué à un autre processus, ...) échoueront. comme s'ils n'étaient pas implémentés. _exitest autorisé, mais le code de sortie est écrasé par un zéro.

Contrairement à l'édition précédente de cette réponse, de nombreux programmes peuvent être presque terminés dans ces conditions; c'est juste que tout leur travail est gaspillé. Par exemple, si vous le faites ./no-syscalls /bin/ls(en supposant que GNU coreutils ls), il lit tout le répertoire et le formate, puis tous les writeappels destinés à produire une sortie échouent. (Cependant, tout ce qui doit ouvrir un canal de communication bidirectionnel, comme tous les clients X11, échouera à ce moment-là. Je pensais autoriser socketmais pas send, mais il semblait trop probable que des échappatoires soient créées.)

Il existe plusieurs options de ligne de commande pour modifier le comportement;

-a  log allowed system calls
-d  log denied system calls
-e  deny everything, not just output
-S  permit writes to stderr

Les programmes liés dynamiquement ne sortiront même pas de l'éditeur de liens dynamique en -emode. -Souvre évidemment un énorme trou dans la politique, mais il peut être amusant de regarder des programmes se plaindre de rien fonctionner, par exemple

$ ./no-syscalls -daeS /bin/ls
syscall 59...
syscall 59 = 0
syscall 12 (denied) = -38
syscall 21 (denied) = -38
syscall 9 (denied) = -38
syscall 20...
/bin/ls: error while loading shared libraries: cannot create cache for search path: Cannot allocate memory
syscall 20 = 107
syscall 231...
Program exited, status = 0

Vous devez lire la sortie du journal avec /usr/include/asm*/unistd.hopen dans une autre fenêtre, car c'est déjà assez long.

Malheureusement, les interfaces de débogueur utilisées par cette dernière ne sont que faiblement cohérentes entre les implémentations Unix et sont intrinsèquement spécifiques au processeur. Il serait relativement simple de le porter sur d'autres architectures de CPU (ajoutez juste les définitions appropriées de SYSCALL_*_REG), et il est probablement possible de le porter sur n'importe quel système Unix ptrace, mais vous devrez peut-être utiliser la liste blanche syscall de manière exhaustive, ainsi que gérer les divergences. dans ptrace.

#define _GNU_SOURCE 1
#include <stddef.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/ptrace.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/user.h>
#include <sys/wait.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#if defined __linux__
# define SYS_unimplemented -1L
# if defined __i386__
#  define SYSCALL_NUMBER_REG regs.orig_eax
#  define SYSCALL_ARG1_REG   regs.ebx
#  define SYSCALL_ARG2_REG   regs.ecx
#  define SYSCALL_ARG3_REG   regs.edx
#  define SYSCALL_ARG4_REG   regs.esi
#  define SYSCALL_RESULT_REG regs.eax
# elif defined __x86_64__
#  define SYSCALL_NUMBER_REG regs.orig_rax
#  define SYSCALL_ARG1_REG   regs.rdi
#  define SYSCALL_ARG2_REG   regs.rsi
#  define SYSCALL_ARG3_REG   regs.rdx
#  define SYSCALL_ARG4_REG   regs.r10
#  define SYSCALL_RESULT_REG regs.rax
# else
#  error "Need to know system call convention for this CPU"
# endif
#else
# error "Need to know system call convention for this OS"
#endif

static long
xptrace(int request, pid_t pid, void *addr, void *data)
{
  errno = 0;
  long rv = ptrace(request, pid, addr, data);
  if (rv == -1 && errno) {
    perror("ptrace");
    if (pid != 0) kill(pid, SIGKILL);
    exit(1);
  }
  return rv;
}
#define GET_REG_(pid, x) \
  xptrace(PTRACE_PEEKUSER, pid, (void*)offsetof(struct user, x), 0)
#define GET_REG(pid, x) GET_REG_(pid, SYSCALL_##x##_REG)
#define SET_REG_(pid, x, v) \
  xptrace(PTRACE_POKEUSER, pid, (void*)offsetof(struct user, x), (void*)v)
#define SET_REG(pid, x, v) SET_REG_(pid, SYSCALL_##x##_REG, v)

/* This function defines the system-call policy.  */
static int
deny_syscall(pid_t pid, int scnum, int deny_all, int allow_stderr)
{
  switch (scnum) {
  /* These syscalls are unconditionally allowed (when not in -e mode);
     they perform input, or change only process-local state. */
#ifdef SYS_access
  case SYS_access:
#endif
#ifdef SYS_alarm
  case SYS_alarm:
#endif
#ifdef SYS_arch_prctl
  case SYS_arch_prctl:
#endif
#ifdef SYS_brk
  case SYS_brk:
#endif
#ifdef SYS_capget
  case SYS_capget:
#endif
#ifdef SYS_clock_getres
  case SYS_clock_getres:
#endif
#ifdef SYS_clock_gettime
  case SYS_clock_gettime:
#endif
#ifdef SYS_clock_nanosleep
  case SYS_clock_nanosleep:
#endif
#ifdef SYS_close
  case SYS_close:
#endif
#ifdef SYS_dup
  case SYS_dup:
#endif
#ifdef SYS_dup2
  case SYS_dup2:
#endif
#ifdef SYS_dup3
  case SYS_dup3:
#endif
#ifdef SYS_epoll_create
  case SYS_epoll_create:
#endif
#ifdef SYS_epoll_create1
  case SYS_epoll_create1:
#endif
#ifdef SYS_epoll_ctl
  case SYS_epoll_ctl:
#endif
#ifdef SYS_epoll_ctl_old
  case SYS_epoll_ctl_old:
#endif
#ifdef SYS_epoll_pwait
  case SYS_epoll_pwait:
#endif
#ifdef SYS_epoll_wait
  case SYS_epoll_wait:
#endif
#ifdef SYS_epoll_wait_old
  case SYS_epoll_wait_old:
#endif
#ifdef SYS_eventfd
  case SYS_eventfd:
#endif
#ifdef SYS_eventfd2
  case SYS_eventfd2:
#endif
#ifdef SYS_faccessat
  case SYS_faccessat:
#endif
#ifdef SYS_fadvise64
  case SYS_fadvise64:
#endif
#ifdef SYS_fadvise64_64
  case SYS_fadvise64_64:
#endif
#ifdef SYS_fanotify_init
  case SYS_fanotify_init:
#endif
#ifdef SYS_fanotify_mark
  case SYS_fanotify_mark:
#endif
#ifdef SYS_fgetxattr
  case SYS_fgetxattr:
#endif
#ifdef SYS_flistxattr
  case SYS_flistxattr:
#endif
#ifdef SYS_fstat
  case SYS_fstat:
#endif
#ifdef SYS_fstat64
  case SYS_fstat64:
#endif
#ifdef SYS_fstatat64
  case SYS_fstatat64:
#endif
#ifdef SYS_fstatfs
  case SYS_fstatfs:
#endif
#ifdef SYS_fstatfs64
  case SYS_fstatfs64:
#endif
#ifdef SYS_ftime
  case SYS_ftime:
#endif
#ifdef SYS_futex
  case SYS_futex:
#endif
#ifdef SYS_getcpu
  case SYS_getcpu:
#endif
#ifdef SYS_getcwd
  case SYS_getcwd:
#endif
#ifdef SYS_getdents
  case SYS_getdents:
#endif
#ifdef SYS_getdents64
  case SYS_getdents64:
#endif
#ifdef SYS_getegid
  case SYS_getegid:
#endif
#ifdef SYS_getegid32
  case SYS_getegid32:
#endif
#ifdef SYS_geteuid
  case SYS_geteuid:
#endif
#ifdef SYS_geteuid32
  case SYS_geteuid32:
#endif
#ifdef SYS_getgid
  case SYS_getgid:
#endif
#ifdef SYS_getgid32
  case SYS_getgid32:
#endif
#ifdef SYS_getgroups
  case SYS_getgroups:
#endif
#ifdef SYS_getgroups32
  case SYS_getgroups32:
#endif
#ifdef SYS_getitimer
  case SYS_getitimer:
#endif
#ifdef SYS_get_kernel_syms
  case SYS_get_kernel_syms:
#endif
#ifdef SYS_get_mempolicy
  case SYS_get_mempolicy:
#endif
#ifdef SYS_getpeername
  case SYS_getpeername:
#endif
#ifdef SYS_getpgid
  case SYS_getpgid:
#endif
#ifdef SYS_getpgrp
  case SYS_getpgrp:
#endif
#ifdef SYS_getpid
  case SYS_getpid:
#endif
#ifdef SYS_getpmsg
  case SYS_getpmsg:
#endif
#ifdef SYS_getppid
  case SYS_getppid:
#endif
#ifdef SYS_getpriority
  case SYS_getpriority:
#endif
#ifdef SYS_getrandom
  case SYS_getrandom:
#endif
#ifdef SYS_getresgid
  case SYS_getresgid:
#endif
#ifdef SYS_getresgid32
  case SYS_getresgid32:
#endif
#ifdef SYS_getresuid
  case SYS_getresuid:
#endif
#ifdef SYS_getresuid32
  case SYS_getresuid32:
#endif
#ifdef SYS_getrlimit
  case SYS_getrlimit:
#endif
#ifdef SYS_get_robust_list
  case SYS_get_robust_list:
#endif
#ifdef SYS_getrusage
  case SYS_getrusage:
#endif
#ifdef SYS_getsid
  case SYS_getsid:
#endif
#ifdef SYS_getsockname
  case SYS_getsockname:
#endif
#ifdef SYS_getsockopt
  case SYS_getsockopt:
#endif
#ifdef SYS_get_thread_area
  case SYS_get_thread_area:
#endif
#ifdef SYS_gettid
  case SYS_gettid:
#endif
#ifdef SYS_gettimeofday
  case SYS_gettimeofday:
#endif
#ifdef SYS_getuid
  case SYS_getuid:
#endif
#ifdef SYS_getuid32
  case SYS_getuid32:
#endif
#ifdef SYS_getxattr
  case SYS_getxattr:
#endif
#ifdef SYS_inotify_add_watch
  case SYS_inotify_add_watch:
#endif
#ifdef SYS_inotify_init
  case SYS_inotify_init:
#endif
#ifdef SYS_inotify_init1
  case SYS_inotify_init1:
#endif
#ifdef SYS_inotify_rm_watch
  case SYS_inotify_rm_watch:
#endif
#ifdef SYS_ioprio_get
  case SYS_ioprio_get:
#endif
#ifdef SYS_kcmp
  case SYS_kcmp:
#endif
#ifdef SYS_lgetxattr
  case SYS_lgetxattr:
#endif
#ifdef SYS_listxattr
  case SYS_listxattr:
#endif
#ifdef SYS_llistxattr
  case SYS_llistxattr:
#endif
#ifdef SYS_lookup_dcookie
  case SYS_lookup_dcookie:
#endif
#ifdef SYS_lseek
  case SYS_lseek:
#endif
#ifdef SYS_lstat
  case SYS_lstat:
#endif
#ifdef SYS_lstat64
  case SYS_lstat64:
#endif
#ifdef SYS_madvise
  case SYS_madvise:
#endif
#ifdef SYS_mbind
  case SYS_mbind:
#endif
#ifdef SYS_mincore
  case SYS_mincore:
#endif
#ifdef SYS_mlock
  case SYS_mlock:
#endif
#ifdef SYS_mlockall
  case SYS_mlockall:
#endif
#ifdef SYS_mprotect
  case SYS_mprotect:
#endif
#ifdef SYS_mremap
  case SYS_mremap:
#endif
#ifdef SYS_munlock
  case SYS_munlock:
#endif
#ifdef SYS_munlockall
  case SYS_munlockall:
#endif
#ifdef SYS_munmap
  case SYS_munmap:
#endif
#ifdef SYS_name_to_handle_at
  case SYS_name_to_handle_at:
#endif
#ifdef SYS_nanosleep
  case SYS_nanosleep:
#endif
#ifdef SYS_newfstatat
  case SYS_newfstatat:
#endif
#ifdef SYS_nice
  case SYS_nice:
#endif
#ifdef SYS_oldfstat
  case SYS_oldfstat:
#endif
#ifdef SYS_oldlstat
  case SYS_oldlstat:
#endif
#ifdef SYS_oldolduname
  case SYS_oldolduname:
#endif
#ifdef SYS_oldstat
  case SYS_oldstat:
#endif
#ifdef SYS_olduname
  case SYS_olduname:
#endif
#ifdef SYS_pause
  case SYS_pause:
#endif
#ifdef SYS_perf_event_open
  case SYS_perf_event_open:
#endif
#ifdef SYS_personality
  case SYS_personality:
#endif
#ifdef SYS_pivot_root
  case SYS_pivot_root:
#endif
#ifdef SYS_poll
  case SYS_poll:
#endif
#ifdef SYS_ppoll
  case SYS_ppoll:
#endif
#ifdef SYS_prctl
  case SYS_prctl:
#endif
#ifdef SYS_pread64
  case SYS_pread64:
#endif
#ifdef SYS_preadv
  case SYS_preadv:
#endif
#ifdef SYS_prlimit64
  case SYS_prlimit64:
#endif
#ifdef SYS_pselect6
  case SYS_pselect6:
#endif
#ifdef SYS_query_module
  case SYS_query_module:
#endif
#ifdef SYS_read
  case SYS_read:
#endif
#ifdef SYS_readahead
  case SYS_readahead:
#endif
#ifdef SYS_readdir
  case SYS_readdir:
#endif
#ifdef SYS_readlink
  case SYS_readlink:
#endif
#ifdef SYS_readlinkat
  case SYS_readlinkat:
#endif
#ifdef SYS_readv
  case SYS_readv:
#endif
#ifdef SYS_recvfrom
  case SYS_recvfrom:
#endif
#ifdef SYS_recvmmsg
  case SYS_recvmmsg:
#endif
#ifdef SYS_recvmsg
  case SYS_recvmsg:
#endif
#ifdef SYS_remap_file_pages
  case SYS_remap_file_pages:
#endif
#ifdef SYS_request_key
  case SYS_request_key:
#endif
#ifdef SYS_restart_syscall
  case SYS_restart_syscall:
#endif
#ifdef SYS_rt_sigaction
  case SYS_rt_sigaction:
#endif
#ifdef SYS_rt_sigpending
  case SYS_rt_sigpending:
#endif
#ifdef SYS_rt_sigprocmask
  case SYS_rt_sigprocmask:
#endif
#ifdef SYS_rt_sigreturn
  case SYS_rt_sigreturn:
#endif
#ifdef SYS_rt_sigsuspend
  case SYS_rt_sigsuspend:
#endif
#ifdef SYS_rt_sigtimedwait
  case SYS_rt_sigtimedwait:
#endif
#ifdef SYS_sched_getaffinity
  case SYS_sched_getaffinity:
#endif
#ifdef SYS_sched_getattr
  case SYS_sched_getattr:
#endif
#ifdef SYS_sched_getparam
  case SYS_sched_getparam:
#endif
#ifdef SYS_sched_get_priority_max
  case SYS_sched_get_priority_max:
#endif
#ifdef SYS_sched_get_priority_min
  case SYS_sched_get_priority_min:
#endif
#ifdef SYS_sched_getscheduler
  case SYS_sched_getscheduler:
#endif
#ifdef SYS_sched_rr_get_interval
  case SYS_sched_rr_get_interval:
#endif
#ifdef SYS_sched_setaffinity
  case SYS_sched_setaffinity:
#endif
#ifdef SYS_sched_setattr
  case SYS_sched_setattr:
#endif
#ifdef SYS_sched_setparam
  case SYS_sched_setparam:
#endif
#ifdef SYS_sched_setscheduler
  case SYS_sched_setscheduler:
#endif
#ifdef SYS_sched_yield
  case SYS_sched_yield:
#endif
#ifdef SYS_select
  case SYS_select:
#endif
#ifdef SYS_setfsgid
  case SYS_setfsgid:
#endif
#ifdef SYS_setfsgid32
  case SYS_setfsgid32:
#endif
#ifdef SYS_setfsuid
  case SYS_setfsuid:
#endif
#ifdef SYS_setfsuid32
  case SYS_setfsuid32:
#endif
#ifdef SYS_setgid
  case SYS_setgid:
#endif
#ifdef SYS_setgid32
  case SYS_setgid32:
#endif
#ifdef SYS_setgroups
  case SYS_setgroups:
#endif
#ifdef SYS_setgroups32
  case SYS_setgroups32:
#endif
#ifdef SYS_setitimer
  case SYS_setitimer:
#endif
#ifdef SYS_setns
  case SYS_setns:
#endif
#ifdef SYS_setpgid
  case SYS_setpgid:
#endif
#ifdef SYS_setpriority
  case SYS_setpriority:
#endif
#ifdef SYS_setregid
  case SYS_setregid:
#endif
#ifdef SYS_setregid32
  case SYS_setregid32:
#endif
#ifdef SYS_setresgid
  case SYS_setresgid:
#endif
#ifdef SYS_setresgid32
  case SYS_setresgid32:
#endif
#ifdef SYS_setresuid
  case SYS_setresuid:
#endif
#ifdef SYS_setresuid32
  case SYS_setresuid32:
#endif
#ifdef SYS_setreuid
  case SYS_setreuid:
#endif
#ifdef SYS_setreuid32
  case SYS_setreuid32:
#endif
#ifdef SYS_setrlimit
  case SYS_setrlimit:
#endif
#ifdef SYS_set_robust_list
  case SYS_set_robust_list:
#endif
#ifdef SYS_setsid
  case SYS_setsid:
#endif
#ifdef SYS_set_thread_area
  case SYS_set_thread_area:
#endif
#ifdef SYS_set_tid_address
  case SYS_set_tid_address:
#endif
#ifdef SYS_setuid
  case SYS_setuid:
#endif
#ifdef SYS_setuid32
  case SYS_setuid32:
#endif
#ifdef SYS_sigaction
  case SYS_sigaction:
#endif
#ifdef SYS_sigaltstack
  case SYS_sigaltstack:
#endif
#ifdef SYS_signal
  case SYS_signal:
#endif
#ifdef SYS_signalfd
  case SYS_signalfd:
#endif
#ifdef SYS_signalfd4
  case SYS_signalfd4:
#endif
#ifdef SYS_sigpending
  case SYS_sigpending:
#endif
#ifdef SYS_sigprocmask
  case SYS_sigprocmask:
#endif
#ifdef SYS_sigreturn
  case SYS_sigreturn:
#endif
#ifdef SYS_sigsuspend
  case SYS_sigsuspend:
#endif
#ifdef SYS_socketpair
  case SYS_socketpair:
#endif
#ifdef SYS_stat
  case SYS_stat:
#endif
#ifdef SYS_stat64
  case SYS_stat64:
#endif
#ifdef SYS_statfs
  case SYS_statfs:
#endif
#ifdef SYS_statfs64
  case SYS_statfs64:
#endif
#ifdef SYS_sysfs
  case SYS_sysfs:
#endif
#ifdef SYS_sysinfo
  case SYS_sysinfo:
#endif
#ifdef SYS_time
  case SYS_time:
#endif
#ifdef SYS_timer_create
  case SYS_timer_create:
#endif
#ifdef SYS_timer_delete
  case SYS_timer_delete:
#endif
#ifdef SYS_timerfd_create
  case SYS_timerfd_create:
#endif
#ifdef SYS_timerfd_gettime
  case SYS_timerfd_gettime:
#endif
#ifdef SYS_timerfd_settime
  case SYS_timerfd_settime:
#endif
#ifdef SYS_timer_getoverrun
  case SYS_timer_getoverrun:
#endif
#ifdef SYS_timer_gettime
  case SYS_timer_gettime:
#endif
#ifdef SYS_timer_settime
  case SYS_timer_settime:
#endif
#ifdef SYS_times
  case SYS_times:
#endif
#ifdef SYS_ugetrlimit
  case SYS_ugetrlimit:
#endif
#ifdef SYS_ulimit
  case SYS_ulimit:
#endif
#ifdef SYS_umask
  case SYS_umask:
#endif
#ifdef SYS_uname
  case SYS_uname:
#endif
#ifdef SYS_unshare
  case SYS_unshare:
#endif
#ifdef SYS_uselib
  case SYS_uselib:
#endif
#ifdef SYS_ustat
  case SYS_ustat:
#endif
#ifdef SYS_wait4
  case SYS_wait4:
#endif
#ifdef SYS_waitid
  case SYS_waitid:
#endif
#ifdef SYS_waitpid
  case SYS_waitpid:
#endif
    return deny_all;

#ifdef SYS_exit
  case SYS_exit:
#endif
#ifdef SYS_exit_group
  case SYS_exit_group:
#endif
    /* Special case: exiting is allowed, even in -e mode,
       but the exit status is forced to 0. */
    SET_REG(pid, ARG1, 0);
    return 0;

#ifdef SYS_fcntl
  case SYS_fcntl:
#endif
#ifdef SYS_fcntl64
  case SYS_fcntl64:
#endif
    /* Special case: fcntl is allowed, but only for the *FD and *FL
       operations.  This is a compromise between not allowing it at
       all, which would break some interpreters, and trying to go
       through the dozens of extended ops and figure out which ones
       can affect global state.  */
    {
      int cmd = GET_REG(pid, ARG2);
      if (cmd == F_DUPFD || cmd == F_DUPFD_CLOEXEC ||
          cmd == F_GETFD || cmd == F_SETFD || cmd == F_SETFL || cmd == F_GETFL)
        return deny_all;
    }
    return 1;

#ifdef SYS_kill
  case SYS_kill:
#endif
#ifdef SYS_rt_sigqueueinfo
  case SYS_rt_sigqueueinfo:
#endif
#ifdef SYS_rt_tgsigqueueinfo
  case SYS_rt_tgsigqueueinfo:
#endif
#ifdef SYS_tkill
  case SYS_tkill:
#endif
#ifdef SYS_tgkill
  case SYS_tgkill:
#endif
    /* Special case: kill is allowed if and only if directed to the calling
       process. */
    {
      pid_t kpid = GET_REG(pid, ARG1);
      if (kpid == pid)
        return deny_all;
    }
    return 1;

#ifdef SYS_mmap
  case SYS_mmap:
#endif
#ifdef SYS_mmap2
  case SYS_mmap2:
#endif
    /* Special case: mmap is allowed if it is private or read-only.  */
    {
      int prot  = GET_REG(pid, ARG3);
      int flags = GET_REG(pid, ARG4);
      if ((flags & (MAP_SHARED|MAP_PRIVATE)) == MAP_PRIVATE)
        return deny_all;
      if (!(prot & PROT_WRITE))
        return deny_all;
    }
    return 1;

    /* Special case: open() variants are allowed only if read-only and
       not creating. */
#ifdef SYS_open
  case SYS_open:
#endif
#ifdef SYS_openat
  case SYS_openat:
#endif
#ifdef SYS_open_by_handle_at
  case SYS_open_by_handle_at:
#endif
    {
      int flags = ((scnum == SYS_open)
                   ? GET_REG(pid, ARG2)
                   : GET_REG(pid, ARG3));
      if (!(flags & O_CREAT) && ((flags & O_ACCMODE) == O_RDONLY))
        return deny_all;
    }
    return 1;

#ifdef SYS_write
  case SYS_write:
#endif
#ifdef SYS_write64
  case SYS_write64:
#endif
#ifdef SYS_writev
  case SYS_writev:
#endif
#ifdef SYS_pwrite
  case SYS_pwrite:
#endif
#ifdef SYS_pwrite64
  case SYS_pwrite64:
#endif
#ifdef SYS_pwritev
  case SYS_pwritev:
#endif
    /* Special case: optionally, the program is allowed to write to
       stderr.  This opens a gaping hole in the policy, but it can be
       quite entertaining to watch programs moan about how nothing works. */
    if (allow_stderr) {
      int fd = GET_REG(pid, ARG1);
      if (fd == 2)
        return 0;
    }
    return 1;

  default:
    /* All other system calls are unconditionally denied. */
    return 1;
  }
}

static void
usage(char *progname)
{
  fprintf(stderr, "usage: %s [-adeS] program args...\n", progname);
  fputs("\t-a  log allowed system calls\n"
        "\t-d  log denied system calls\n"
        "\t-e  deny everything, not just output\n"
        "\t-S  permit writes to stderr\n", stderr);
  exit(2);
}

int
main(int argc, char **argv)
{
  pid_t pid;
  int   status;
  int   opt;
  long  last_syscall = SYS_unimplemented;
  int   last_allowed = 0;
  int   after_execve = 0;
  int   trace_active = 0;
  int   allow_stderr = 0;
  int   deny_all     = 0;
  int   log_allowed  = 0;
  int   log_denied   = 0;

  while ((opt = getopt(argc, argv, "+adeS")) != -1) {
    switch (opt) {
    case 'a': log_allowed  = 1; break;
    case 'd': log_denied   = 1; break;
    case 'e': deny_all     = 1; break;
    case 'S': allow_stderr = 1; break;
    default:
      usage(argv[0]);
    }
  }
  if (optind == argc) {
    usage(argv[0]);
  }

  setvbuf(stdout, 0, _IOLBF, 0);
  setvbuf(stderr, 0, _IOLBF, 0);

  pid = fork();
  if (pid == -1) {
    perror("fork");
    exit(1);

  } else if (pid == 0) {
    raise(SIGSTOP); /* synch with parent */
    execvp(argv[optind], argv+optind);
    perror("execvp");
    exit(1);
  }

  /* If we get here, we are the parent. */
  for (;;) {
    pid_t rv = waitpid(pid, &status, WUNTRACED);
    if (rv != pid) {
      perror("waitpid");
      kill(pid, SIGKILL);
      exit(1);
    }
    if (!WIFSTOPPED(status)) {
      if (WIFEXITED(status))
        printf("Program exited, status = %d\n", WEXITSTATUS(status));
      else if (WIFSIGNALED(status))
        printf("Program killed by signal %d\n", WTERMSIG(status));
      else {
        printf("Un-decodable status %04x\n", status);
        kill(pid, SIGKILL); /* just in case */
      }
      exit(0);
    }
    if (WSTOPSIG(status) == SIGSTOP && !trace_active) {
      /* This is the raise(SIGSTOP) on the child side of the fork. */
      trace_active = 1;
      xptrace(PTRACE_SEIZE, pid, 0, (void*)PTRACE_O_TRACESYSGOOD);
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    }
    else if (WSTOPSIG(status) == (SIGTRAP|0x80)) {
      if (last_syscall == SYS_unimplemented) {
        last_syscall = GET_REG(pid, NUMBER);
        /* The child process is allowed to execute normally until an
           execve() succeeds.  */
        if (after_execve && deny_syscall(pid, last_syscall,
                                         deny_all, allow_stderr)) {
          last_allowed = 0;
          SET_REG(pid, NUMBER, SYS_unimplemented);
        } else {
          last_allowed = 1;
          if (log_allowed) {
            /* Log this now, we may not get another chance. */
            printf("syscall %ld...\n", last_syscall);
          }
        }
      } else {
        if (last_allowed ? log_allowed : log_denied) {
          long scret = GET_REG(pid, RESULT);
          printf("syscall %ld%s = %ld\n",
                 last_syscall, last_allowed ? "" : " (denied)", scret);
        }
        if (last_allowed && (last_syscall == SYS_execve ||
                             last_syscall == SYS_execveat)) {
          long scret = GET_REG(pid, RESULT);
          if (scret == 0)
            after_execve = 1;
        }
        last_syscall = SYS_unimplemented;
      }
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    }
    else if (WSTOPSIG(status) == SIGTRAP) {
      /* Swallow all SIGTRAPs, they are probably spurious debug events. */
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    } else {
      /* Allow all normal signals to proceed unmolested. */
      if (log_allowed) {
        printf("process received signal %d\n", WSTOPSIG(status));
      }
      xptrace(PTRACE_SYSCALL, pid, 0, (void*)(uintptr_t)WSTOPSIG(status));
    }
  }
}

Texas

\catcode`\\=10

Je ne suis pas sûr que cela fonctionnera réellement, mais en théorie, cela devrait être considéré \comme un personnage d'évasion ne vous laissant aucun moyen de le réparer. Normalement TeX peut lire et écrire des fichiers, maintenant il ne peut rien écrire qui dépende de la logique. Ainsi, le langage est maintenant cassé comme défini par OP.

EDIT: Autres commandes kill issues des commentaires (même si les deux peuvent enfreindre la règle code-must-be-execute):

• \def\fi{}\iffalsepar smpl crée une branche non fermable si
• \catcode13=9%par iwillnotexist idonotexist crée un commentaire sans fin

Rayure

Le when [timer v] > (0)sera exécuté dès que le code est initialisé, ce qui, si vous êtes dans l'éditeur, est avant même de commencer le code. Le when I receive (join[][])provoquera une erreur d'être jeté chaque fois que quelque chose est diffusé, une pause exécution de code si vous avez la version Developer de Flash. La breakfonction créera des clones et déclenchera l'erreur de diffusion. Chaque clone durera deux secondes, puis se supprimera lui-même, mettant la pile à rude épreuve. Et chaque clone répondra à when [timer v] > (0), en exécutant le breaksous - programme et en réinitialisant le chronomètre, ce qui entraînera la réexécution du code du chronomètre. En outre, chaque clone répondra également à chaque erreur de diffusion, ce qui signifie que le nombre d'erreurs par évaluation breakest le nombre de clones au carré. Ai-je oublié de mentionner que la breakfonction arun without screen refreshcoché, ce qui a pour effet de geler, secouer et retarder l’éditeur, ainsi que de saisir et d’allouer de la mémoire. Et maximiser le CPU.

Tout code ajouté n'importe où avec cette exécution se trouvera dans l'impossibilité de créer des clones (limite de 300 clones dépassée), ainsi que de chauffer et de planter l'ordinateur en cours d'exécution. Et saisir la mémoire jusqu'à ce qu'il n'y ait plus rien à saisir, laissant les variables se comporter mal.

Et, après un délai trop long pour déclencher le when [timer v] > (0)blocage, il fonctionnera toujours break.

Merci à @towerofnix de m'avoir rappelé le when I receiveproblème que j'ai constaté il y a un certain temps et de m'avoir donné l'idée de le faire run without screen refresh. Si vous avez aimé ceci, voici l'original: https://codegolf.stackexchange.com/a/61357/43394

Mathematica / Wolfram Language

Mathematica est un langage interprété dans lequel les noms de commande sont des symboles pouvant être manipulés par le programmeur. Vous ne pouvez pas supprimer les opérateurs intégrés, mais vous pouvez les surcharger ou modifier leur fonction. Ce qui suit brouille la commande "Avec", nécessaire pour l'affectation de variables même en interne. Cette modification empêche le noyau de conserver les arguments non évalués jusqu'à la fin de l'affectation et tue la langue complètement morte.

ClearAttributes["With", HoldAll]

Si cette commande est exécutée dans une session interactive ou dans un bloc de code, Mathematica ne pourra même pas l'ajouter 1+1(le message d'erreur résultant concerne une page, donc je ne l'inclurai pas ici).

PHP

Je suis surpris que cela fonctionne réellement, mais la fermeture STDOUTet STDERRsupprime toutes les sorties. Pour être sûr qu'ils ne seront pas rouverts, nous avons ouvert /dev/nulltrois fois pour réaffecter les descripteurs de fichier 0, 1 et 2:

<?php
fclose(STDIN);
fclose(STDOUT);
fclose(STDERR);
fopen('/dev/null','r');
fopen('/dev/null','w');
fopen('/dev/null','w');

// insert program here

Plus à ce sujet: https://stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

Lot DOS (avant Windows 95, je crois)

CTTY

Émis sans argument, cela déconnecte la ligne de commande du terminal. Toute autre tentative de lire une entrée ou de générer une sortie ne fait rien.

Si vous voulez savoir comment utiliser correctement CTTY:

MODE COM1,8600,8,N,1
CTTY COM1

Un fichier de commandes légèrement plus puissant pourrait même répondre au modem et connecter tout ce qui a été appelé à CTTY.

Common Lisp

(set-macro-character #\( (lambda (x y) ()))

J'espère que vous n'avez pas besoin de ces parenthèses d'ouverture.

Il s'agit d'une macro de lecteur qui demande au lecteur Lisp de remplacer chaque instance de (avec un appel à (lambda (x y) ()), une fonction qui prend deux arguments et ne retourne rien. Ainsi, par exemple, il se lirait (foo)comme foo), interpréter foocomme une variable et ensuite lancer une erreur de parenthèse sans correspondance 0.

Rayure

Voici un exemple assez simple qui va bloquer votre navigateur (et, en théorie, votre ordinateur):

Je l'ai laissé fonctionner pendant environ vingt secondes, puis j'ai perdu 2,65 Go de mémoire pour Scratch. Seulement un moment plus tard et 5 Go étaient partis.

Je suggère fortement que vous ayez un moyen de forcer Adobe Flash ou votre navigateur Web à quitter Adobe Flash avant de lancer ceci!

^{Je voulais vraiment faire une bonne réponse comme celle de clear(this)JS, mais malheureusement, Scratch n’a aucun moyen de le faire. N'hésitez pas à mettre à jour ce post (ou à créer le vôtre) si vous trouvez un autre moyen de rendre Scratch inutilisable!}

Thue

::=

Avec une nouvelle ligne à la fin

Le langage thue repose sur la définition de jeux de règles et un ::=indique la fin du jeu de règles. Il est impossible de faire RIEN dans Thue sans définir des règles qui le font, donc peu importe ce que vous mettez après ::=, rien ne peut arriver.

Réponse alternative

A::=
B::=
C::=
D::=
E::=
F::=
G::=
H::=

(et ainsi de suite pour tous les caractères de l’Unicode, y compris ceux précédant le Acaractère et les caractères non imprimables). Cela nécessite l'option de ligne de commande -r.

MATLAB

Le code suivant rend l'environnement complètement inutilisable ¹ :

builtin = @(varargin)false; clear = @(varargin)false;
%// Insert code after this point

Cela remplace la builtinfonction et la clearfonction avec les nouvelles poignées de fonction anonymes qui reviennent simplement à falsechaque fois que vous essayez et appelez ces fonctions. La builtinfonction garantit que s'il y a des fonctions personnalisées que vous écrivez dans Matlab qui sont le même nom que ceux qui sont intégrés à Matlab ( des choses comme sum, max, min, etc.), vous êtes en mesure d'appeler ceux - ci sans ambiguïté au lieu des fonctions surchargées . De même, clearvous donne la possibilité d'effacer toutes les variables actuellement déclarées pour pouvoir recommencer à zéro. En supprimant ces fonctionnalités, vous ne pouvez utiliser MATLAB que si vous redémarrez le programme.

Dans MATLAB R2015a, je reçois également le message suivant:

L'espace de travail sont les variables actuellement déclarées dans l'environnement afin que vous puissiez les utiliser pour plus tard. Ceci désactive de manière permanente l'espace de travail. Ainsi, les variables que vous essayez de créer ne seront pas enregistrées. Par conséquent, aucun progrès ne peut être réalisé lors de l'exécution de lignes de code dans MATLAB.

^{1: le crédit va à l'utilisateur Dev-iL qui a découvert l'idée à l'origine.}

///

/\///

La seule opération est répétée /// substitution de chaîne, comme ceci: /pattern/replacement/.

Ce code supprime tous les cas /. De cette manière, vous ne pouvez pas utiliser la substitution de chaînes répétée. Ainsi, tout ce que vous écrivez après sera imprimé (à l'exception de /s).

Vous pouvez toujours utiliser \s, mais cela ne vous aidera pas beaucoup.

Befunge-96

'~h

Le code de l'utilisateur peut suivre n'importe où après cette séquence, à condition qu'il s'agisse des trois premiers caractères de la source.

La 'commande (mode chaîne à une séquence) insère la valeur ASCII de l' ~icône dans la pile (c.-à-d. 126), hpuis définit ce que l'on appelle le delta holistique avec cette valeur. Pour ceux qui ne sont pas familiers avec Befunge-96, le Delta holistique est un décalage qui est ajouté à la valeur de chaque octet de commande rencontré par l'interpréteur.

Une fois que le delta est défini sur 126, la seule commande valide pouvant être générée est ~(saisie de caractères), via un octet nul dans la source. Toute valeur autre qu'un octet nul se traduirait par une valeur supérieure à 126 et aucune de ces valeurs ne serait une commande Befunge valide.

Je pense qu'il est prudent de dire que cela rendrait inéligible le qualificatif de langage de programmation.

Huer

macro harmless:
    Context.Parameters.Pipeline.Clear()

Et puis, quelque part dans le projet,

harmless

Une simple macro avec un nom qui sonne bien, mais dont l’effet est incroyablement frustrant. Le compilateur Boo utilise un pipeline en plusieurs étapes qui commence par l’analyse de la source dans un AST et se termine par la génération de code. (En général. Il peut être reconfiguré pour diverses applications.) Chaque étape intermédiaire effectue diverses opérations sur l'AST.

La phase d'expansion des macros est en cours d'exécution, au cours de laquelle les macros sont exécutées dans le contexte du compilateur. Rappelez-vous le bit dans le dernier paragraphe, à propos de la reconfiguration du pipeline? Si, lors du développement d'une macro, vous appelez une macro qui efface le pipeline, aucune erreur ne sera affichée à l'utilisateur, mais toutes les étapes après le développement de la macro (y compris la génération de code) n'y sont plus. Vous obtenez donc quelque chose qui ressemble à une compilation réussie - aucun message d'erreur ne s'affiche - mais pour une raison quelconque, aucun fichier binaire n'est généré! Garanti de conduire même les meilleurs dépanneurs sur le mur, si vous cachez bien la macro et l'invocation.

NGN / APL

NGN / APL permet de redéfinir les primitives, donc redéfinir ( ←) toutes les fonctions primitives en ⊢("passer à travers": les deux ⊢3et 2⊢3donne 3) rend le langage complètement inutile:

⍪←-←+←?←⍵←∊←⍴←~←↑←↓←⍳←○←*←⌈←⌊←⍕←⊂←⊃←∩←∪←⊥←⊤←|←<←≤←=←≥←>←≠←∨←∧←×←÷←⍒←⍋←⌽←⍉←⊖←⍟←⍱←⍲←!←⌹←⊣←⍎←⊢

Essayez ici.

Ruby (29 caractères)

class Object;def send;end;end

As 'send' est utilisé en interne à chaque fois qu'une méthode est appelée dans Ruby et que tous les objets héritent de la classe Object. Cela devrait arrêter toute méthode en cours d'exécution.

Fait amusant: Ceci est parfaitement valable en théorie. Mais il semble, pour une raison quelconque, ne pas entraver le langage Ruby. Je ne sais pas pourquoi il est possible d'exécuter ce code et d'utiliser tout de même un environnement Ruby ouvert.

Tcl

foreach x [info commands] {if {$x!="rename"&&$x!="if"} {rename $x ""}}

Cela supprime tous les mots-clés de la langue sauf ifet rename.

Le code ci-dessus entraînerait la sortie de tout nouveau code. Il est donc discutable de savoir si le nouveau code inséré est "exécuté". Ci-dessous, une version qui exécute le nouveau code mais ne fait rien car elle modifie tous les mots-clés (à l'exception de ifet proc) en une opération non-exécutable:

foreach x [info commands] {if {$x!="if"&&$x!="proc"} {
    proc $x args {}
}}

Au lieu de supprimer des mots-clés, ce code les remplace par une fonction qui ne fait rien.

(Remarque: j'utilise très vaguement les "mots-clés" parce que Tcl n'a pas de mots-clés, seulement des fonctions)

Hoon

=<  ~
(your code)

Hoon est un étrange. C'est à peu près tout à fait différent des autres langages de programmation, pas seulement en syntaxe mais en sémantique. Contrairement à des langues comme Hexagony, cependant, ce n'était pas fait pour être ésotérique à dessein.

Hoon compile to Nock , une VM virtuelle basée sur un combinateur minimal. Nock est stupide: la spécification peut être compressée à 340 octets. La seule opération mathématique est l'incrémentation. Tout est un nom: un atome (bignum) ou une cellule (paire de noms), le modèle de mémoire entier étant organisé dans un arbre binaire acyclique immuable. La seule sortie est le nom que votre expression se réduit à.

En raison de la cible de compilation étrange, Hoon est aussi étrange: c'est complètement pur. Hoon compile jusqu'à une expression Nock évaluée sur un "contexte". Le noyau entier et stdlib, ainsi que toutes les variables, sont transmis implicitement au programme par le contexte.

Pour rendre Hoon inutilisable, nous utilisons simplement =<"évaluer a dans le contexte de b". Nous évaluons toujours ~ce qui est zéro. Quoi qu’il en soit b, il ne peut pas changer la valeur à laquelle il se réduit, et comme il ne peut avoir d’effet secondaire, il ne peut pas faire d’entrée ou de sortie.

Note latérale: Comme vous ne pouvez pas réellement demander à Hoon (pureté!), Selon les règles, il ne s'agit pas d'un langage de programmation. L'entrée s'effectue via les arguments de la fonction, la sortie via les valeurs de retour (ou ~&, qui est davantage une fonctionnalité de débogage de printf et est transparente pour le programme).

Pour qu’un programme reçoive une entrée dans Urbit, vous écrivez en fait un programme qui renvoie une fonction qui accepte une entrée, et le shell vous demande en votre nom et le transmet au rappel.

Taxi, 2354 octets.

Ce petit programme consiste simplement à faire rouler le taxi dans une grande balade à travers Townsburg, en panne d’essence. Tout code que vous exécutez après cela provoquera rapidement une erreur error: out of gas. Et même si vous pouviez atteindre une station-service, ce que je ne pense pas possible, vous ne pourriez pas obtenir d'essence car aucun argent n'a été collecté, car il n'y a pas de passagers.

Go to Trunkers: west, 1st right, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st left, 1st left, 1st right.

JavaScript dans le navigateur

Eh bien, au moins dans IE11.

window.addEventListener("error", function(){});
document = document.write = alert = prompt = confirm = console = void(
    (function (window) {
        try {
            //Code goes here
        } catch (e) {}
    })({})
);

Désactive l'écriture dans le document, l'écriture dans la variable globale et le renvoi depuis la fonction.

Commentez si j'ai raté une méthode de sortie!

Python 2, incroyablement grand

import rexec, ihooks, types, os, struct,sys,imp
from functools import update_wrapper as do_update, wraps
__all__ = ["RExec","enable"]
trashed = False
from ctypes import pythonapi, POINTER, py_object
getdict = pythonapi._PyObject_GetDictPtr
getdict.restype = POINTER(py_object)
getdict.argtypes = [py_object]
modified = ctypes.pythonapi.PyType_Modified
modified.argtypes = [ctypes.py_object]
def dictionary_of(ob):
    dptr = getdict(ob)
    if dptr and dptr.contents:
        return dptr.contents.value
RESTRICTED = "NOT AVAILABLE"
class RExec(rexec.RExec):
    ok_sys_names = rexec.RExec.ok_sys_names + ("warnoptions","py3kwarning","flags")
    nok_sys_strings = ("executable",)
    ok_builtin_modules = rexec.RExec.ok_builtin_modules + ("cStringIO","exceptions","_collections","itertools","_hashlib","_codecs","_functools","_struct")
    def __init__(self, hooks = None, verbose = 0):
        ihooks._Verbose.__init__(self, verbose)
        self.hooks = hooks or rexec.RHooks(verbose)
        self.hooks.set_rexec(self)
        self.modules = {}
        self.ok_dynamic_modules = self.ok_builtin_modules
        list = []
        for mname in self.ok_builtin_modules:
            if mname in sys.builtin_module_names:
                list.append(mname)
        self.ok_builtin_modules = tuple(list)
        self.set_trusted_path()
        self.make_builtin()
        self.make_initial_modules()
        self.make_sys()
        self.loader = rexec.RModuleLoader(self.hooks, verbose)
        self.importer = rexec.RModuleImporter(self.loader, verbose)
        self.make_StringIO()
    def make_sys(self):
        old_rexec.make_sys(self)
        sys_ = self.modules["sys"]
        for name in dir(sys):
            obj = getattr(sys,name)
            if "__" not in name and type(obj) == str and \
              not hasattr(sys_,name):
                if name in self.nok_sys_strings:
                    obj = RESTRICTED
                setattr(sys_,name,obj)
        sys_.argv = [RESTRICTED]
    def make_initial_modules(self):
        old_rexec.make_initial_modules(self)
        self.copy_except(types,["__builtins__"])
        self.copy_except(os.path,["__builtins__"])
        b = self.modules["__builtin__"]
        for module in self.modules.itervalues():
            module.__builtins__ = b
    def make_StringIO(self):
        t = type(self.r_open)
        if t == types.ClassType or t == type:
            return
        elif t != types.FunctionType and t != types.MethodType:
            raise RuntimeError
        io = self.r_import("StringIO").StringIO
        old_open = self.r_open
        class r_open(io):
            def __init__(self,*openargs):
                o = old_open(*openargs)
                if o.isatty():raise IOError
                io.__init__(self,o.read())
            def __enter__(self):
                return self
            def __exit__(self,type,val,tb):
                self.close()
            for name in "truncate write flush".split():
                exec "def %s(self,arg=None):raise IOError('File not open for writing')" % name
            del name
        ntypes = self.modules["types"]
        b = self.modules["__builtin__"]
        ntypes.FileType = self.r_open = b.open = b.file = r_open
    def r_import(self,name,globals={},locals={},fromlist=[],level=-1):
        redone = name in self.modules
        found = False
        try:
            result = self.importer.import_module(name, globals, locals, fromlist,level)
        except ImportError:
            if name == "imp":
                result = imp.new_module("imp")
                self.modules["imp"]=result
                found = True
            if not found:raise
        if redone:pass #Only do this once
        elif name == "sysconfig":
            result._PROJECT_BASE = "x"
            result._CONFIG_VARS = {}
        elif name == "functools":
            update = result.update_wrapper
            def update_wrapper(wrapper,wrapped,assigned=(),updated=()):
                return update(wrapper,wrapped,assigned,updated)
            do_update(update_wrapper,update)
            result.update_wrapper = update_wrapper
            def wraps(wrapped,*args,**kw):
                return result.partial(update_wrapper,wrapped=wrapped,*args,**kw)
            do_update(wraps,result.wraps)
            result.wraps = wraps
        return result
    def s_apply(self,func,args=(),kw=None):
        kw = kw or {}
        if getattr(func,"__stdin_trashing",False):
            kw["s_applied"] = True
        return old_rexec.s_apply(self,func,args,kw)
    r_exc_info = staticmethod(sys.exc_info)
    def r_method(name):
        l = {}
        exec \
"""def %s(self,*args,**kwargs):
    s_applied = kwargs.pop("s_applied",False)
    if kwargs:raise TypeError
    if not s_applied:
        self.save_files()
        sys.stdin = sys.stdout = sys.stderr = None
    global restrictedly
    restrictedly = True
    try:
        return old_rexec.%s(self,*args)
    finally:
        restrictedly = False
        if not s_applied:
            self.restore_files()
setattr(%s,"__stdin_trashing",True)""" % (name,name,name) in globals(),l
        return l[name]
    r_exec = r_method("r_exec")
    r_eval = r_method("r_eval")
    del r_method
old_rexec = rexec.RExec
class ModuleImporter(ihooks.ModuleImporter):
    def determine_parent(self, globals, level=-1):
        if not globals or not level:return None
        pkgname = globals.get('__package__')
        if pkgname is not None:
            if not pkgname and level > 0:raise ValueError, 'Attempted relative import in non-package'
        else:
            modname = globals.get('__name__')
            if modname is None:return None
            if "__path__" in globals:pkgname = modname
            else:
                # normal module, work out package name if any
                if '.' not in modname:
                    if level > 0:raise ValueError, ('Attempted relative import in non-package')
                    globals['__package__'] = None
                    return None
                pkgname = modname.rpartition('.')[0]
            globals['__package__'] = pkgname
        if level > 0:
            dot = len(pkgname)
            for x in range(level, 1, -1):
                try:
                    dot = pkgname.rindex('.', 0, dot)
                except ValueError:raise ValueError('attempted relative import beyond top-level package')
            pkgname = pkgname[:dot]
        try:
            return self.modules[pkgname]
        except KeyError:
            if level < 1:
                warn("Parent module '%s' not found while handling "
                     "absolute import" % pkgname, RuntimeWarning, 1)
                return None
            else:raise SystemError, ("Parent module '%s' not loaded, cannot perform relative import" % pkgname)
restrictedly = False
def enable():
    rexec.RExec = RExec
    rexec.RModuleImporter = ModuleImporter
    global trashed
    if not trashed:
        subclasses = type.__subclasses__
        error = None
        def restrict(fun):
            error_ = error
            def censored(*args):
                global restrictedly
                if restrictedly:
                    if error_ is not None:
                        return error_
                    raise RuntimeError
                return fun(*args)
            return censored
        error = ()
        dictionary_of(type)["__subclasses__"]=restrict(subclasses)
        error = None
        modified(type)
        #Stop uses of frames (created using with statements)
        old_frame = types.TracebackType.tb_frame
        @property
        @restrict
        def new_frame(self):
            return old_frame.__get__(self,types.TracebackType)
        @new_frame.setter
        def new_frame(self,v):
            raise TypeError("Readonly attribute")
        dictionary_of(types.TracebackType)["tb_frame"] = new_frame
        modified(types.TracebackType)
        trashed = True
def test():
    enable()
    r = RExec()
    try:
         r.r_exec(
                """Your code goes here!"""
             )
    finally:
        return 0
if __name__ == "__main__":
    enable()
    test()
    sys.exit()

Cette quantité incroyablement grande de code est une renaissance du rexecmodule ancien (abandonné dans Python 2.3) avec un groupe de nouveaux modules ajoutés à la liste "ok" et un groupe de faiblesses corrigées (y compris la object.__subclasses__()méthode qui a créé au moins deux autres logiciels python. réponses invalides).

Une bonne partie de ce code (la __init__méthode de la RExecclasse et la ModuleImporterclasse entière ) est copiée à partir de la bibliothèque standard Python avec de petites modifications.