Cerca di scrivere del codice nella tua lingua e di non soddisfare più i nostri criteri di linguaggio di programmazione .

Un linguaggio soddisfa i nostri criteri (versione semplificata per questa sfida) di essere un linguaggio di programmazione se:

• Può in qualche modo leggere l'input dell'utente che rappresenta tuple di numeri interi positivi.
• Può produrre almeno due diversi risultati possibili a seconda dell'ingresso.
• Può richiedere due numeri interi positivi e aggiungerli (e il risultato può influire sull'output).
• Può prendere un numero intero positivo e decidere se si tratta di un numero primo (e il risultato può influire sull'output).
• Ai fini di questa sfida, viene ignorato qualsiasi tipo di output che non sia un metodo di output consentito per una sfida normale . Quindi non importa se il programma può anche riprodurre un brano musicale o postare tramite HTTP, ecc.
• Aggiornamento: è inoltre possibile scegliere uno o alcuni dei metodi di output consentiti e ignorare tutti gli altri. Ma devi usare la stessa definizione ovunque nei seguenti criteri. E se il tuo programma può disabilitare più di un metodo di output, vale più voti.

Esempi come renderlo non in grado di produrre output o disabilitare tutti i costrutti di loop in modo che non sia in grado di eseguire test di primalità e assicurarsi che l'utente non possa riattivarli.

Dovresti lasciare un posto per inserire un nuovo codice. Per impostazione predefinita, è alla fine del codice. Se consideriamo di inserire il codice sorgente in quel punto nella tua risposta e di eseguire il codice completo come programma completo come interprete di una nuova lingua, quella lingua non dovrebbe soddisfare i criteri.

Ma il codice inserito deve essere eseguito in modo simile a un linguaggio che soddisfi i criteri:

• Il codice inserito deve essere grammaticalmente uguale a qualcosa (diciamo che è un blocco di codice nei seguenti criteri) che generalmente soddisfano i criteri, dal punto di vista di chiunque voglia scrivere un evidenziatore di sintassi. Quindi non può essere in una stringa, un commento, ecc.
• Il codice inserito deve essere effettivamente eseguito, in modo tale da soddisfare i criteri. Quindi non può essere in una funzione inutilizzata o sizeofin C, non è possibile eseguire solo una parte non funzionale nel codice e non è possibile inserirlo dopo un ciclo infinito, ecc.
• Non è possibile limitare il numero di possibili programmi grammaticalmente corretti generati in questo modo. Se esiste già qualcosa come un limite di lunghezza nella lingua che stai utilizzando, non dovrebbe soddisfare i criteri anche se questo limite viene rimosso.
• Non è possibile modificare o "esaurire" il contenuto di input / output, ma è possibile impedirne l'accesso.
• Questi criteri di solito si applicano solo alle lingue senza I / O esplicito:
  • Il tuo codice dovrebbe reindirizzare l'input dell'utente (che contiene informazioni di lunghezza arbitraria) al codice inserito, se un blocco di codice non è in genere in grado di ottenere l'input dell'utente direttamente / esplicitamente nella lingua che stai utilizzando.
  • Il tuo codice dovrebbe stampare il valore restituito del codice inserito, se un blocco di codice non è in genere in grado di produrre oggetti direttamente / esplicitamente nella lingua che stai utilizzando.
  • Nel caso in cui si stampi il valore restituito, ed è digitato nella lingua che si sta utilizzando, il tipo restituito dovrebbe essere in grado di avere 2 diversi valori praticamente possibili. Ad esempio, non è possibile utilizzare il tipo struct {}o struct {private:int x;}in C ++.

Questo è concorso di popolarità. La risposta valida più votata (quindi nessuno ha individuato un errore o tutti gli errori sono stati corretti) vince.

chiarimenti

• Non è necessario modificare il codice nel modulo di testo, ma è possibile modificare la sintassi prima che il codice venga interpretato o compilato.
• Puoi fare altre cose mentre il codice è in esecuzione. Ma il motivo per cui non soddisfa i criteri dovrebbe essere all'interno del codice inserito stesso. Può sbagliare a causa dell'interferenza di un altro thread, ma non può essere ucciso solo da un altro thread.
• Tutte le specifiche sostanzialmente indicano che dovrebbe essere grammaticalmente probabile che soddisfi i criteri se tutti gli built-in non sono stati modificati ma in realtà non lo fanno. Va bene se trovi soluzioni alternative non grammaticali, come passare correttamente i parametri al blocco di codice, ma rendili non utilizzabili in qualche modo.
• Ancora una volta, il codice inserito deve essere effettivamente eseguito. Il codice dopo un ciclo infinito o un arresto anomalo è considerato "non effettivamente eseguito", quindi non valido . Quelle risposte potrebbero essere interessanti, ma ci sono già alcune altre loop infiniti o domande che si arrestano in modo anomalo su questo sito e potresti trovarne una più appropriata per rispondere. In caso contrario, considera di porre una nuova domanda. Esempi di tali domande sono:
  • Il ciclo infinito più breve non produce output
  • Perché non finisce?
  • Loop senza "loop"
  • Sfida: scrivi un pezzo di codice che si chiude da solo
  • Errori di runtime ridicoli
  • Blocca il tuo compilatore preferito

Classifica

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>

Shell JavaScript

Ciò renderà la lingua completamente inutilizzabile.

clear(this);

Non è carino come JavaScript abbia una funzione così bella da distruggersi?

Questo è piuttosto semplice, la clearfunzione svuota completamente un oggetto. thissi riferisce all'oggetto globale che cancella tutto, inclusi costruttori e funzioni.

Perché questo cancella tutto , facendo qualsiasi cosa , anche la definizione di un letterale genererà un errore, rendendo la lingua completamente inutile: _{* Ambiente REPL non richiesto. Utilizza il motore SpiderMonkey (shell non browser), il motore JS originale.}

Emmental

;#33!

So che questo non è il golf del codice, ma lo strumento giusto per il lavoro, sai ...

Il codice dell'utente può essere inserito dopo il !.

Emmental è un esolang interessante che si basa sulla riscrittura dell'interprete. Ogni singolo simbolo (compresi quelli incorporati) può essere ridefinito come un programma Emmental arbitrario. Il linguaggio si basa su questa funzionalità così tanto da non fornire alcun costrutto loop. Invece, si definiscono comandi ricorsivi che compaiono nelle proprie definizioni.

Questa ridefinizione avviene tramite !, che legge un personaggio dallo stack, quindi legge una stringa dallo stack fino a quando non incontra un ;. Il carattere viene quindi ridefinito per indicare il programma rappresentato da quella stringa.

Ciò significa che possiamo disabilitare le funzionalità di loop di Emmental ridefinendo ! se stesso come programma vuoto. Mentre tutti gli altri codici Emmental funzionano ancora perfettamente, e molti dei criteri di un linguaggio di programmazione sono ancora soddisfatti, è impossibile ridefinire altri simboli. Senza questa funzione (e quindi, senza essere in grado di eseguire il loop), Emmental non può più verificare se un numero è primo.

PHP

Si può uccidere completamente PHP impostando il limite di memoria su 1.

Morirà completamente.

Prova questo:

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

    //code here

Questo non dovrebbe nemmeno generare alcun errore, poiché non c'è abbastanza memoria per quello.

Puoi leggere di più sulla memory_limitdirettiva

Se il precedente non è valido, è possibile utilizzare i buffer di output:

<?php
    ob_start();

    //code here

    ob_clear();

Questo rimuove completamente qualsiasi output. Poiché il buffer di output è ancora aperto, alcune altre cose lasciate accidentalmente dopo che il codice non verrà mostrato.

Usando l'idea di @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();

Ciò eviterà il problema di eliminare il buffer di output avviato automaticamente, utilizzato per catturare l'output da comprimere.

Ciò impedisce anche che il buffer di output venga eliminato o scaricato (inviato al browser). Per rinforzare ciò, viene aggiunto un gestore di output, che restituisce sempre una stringa vuota.
L'esecuzione ob_end_flush(); echo "Hello, world!";non produrrà nulla, ma invierà l'output con un semplice ob_start();.

Grazie a @LucasTrzesniewski per aver esposto questo problema!

codice macchina x86 in modalità reale (=> quasi tutti i programmi DOS)

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

vale a dire

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

Spero che non fossi troppo attaccato alla tua tabella degli interrupt.

Giava

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

Modifica: le contromisure contrarie stanno rendendo questo gigante :(

Reindirizza stdin e stdout su flussi null e sostituisce args con un array vuoto. Utilizza anche enormi quantità di hack di riflessione per assicurarsi che l'IO standard sia veramente nascosto. Infine, imposta un gestore della sicurezza per assicurarsi che l'IO standard non possa essere ricreato e che i programmi non possano impostare il codice di uscita.

Lua

_ENV=""

In Lua, _ENVè l'ambiente in cui sono archiviate tutte le variabili, funzioni, tabelle, ecc. Globali. Definirlo come una stringa vuota significa che non è possibile definire nulla di nuovo e che tutte le funzioni e variabili vengono cancellate. Ciò significa che non puoi produrre nulla, accettare input o praticamente fare qualsiasi cosa.

Shakespeare Programming Language

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]

In SPL, il parser incorporato che viene scaricato con il programma segue regole molto specifiche su ciò che può accadere nello script. Una di queste regole è che solo due personaggi possono essere sul palco contemporaneamente. Inoltre, far uscire un personaggio dal palco che non era mai sul palco lo confonderà. Lo stesso vale per l'aggiunta di un personaggio sul palco che è già sul palco. Quando il parser riceve un errore, rifiuterà di fare NIENTE altro; devi letteralmente spegnere completamente il programma e il parser e quindi riavviare tutto.

PS Se non hai idea di come funzioni questa lingua, Google. È meraviglioso.

Smalltalk

Non sono sicuro se questo si qualifica:

Smalltalk := Nil.

Ciò elimina l'intero ambiente di runtime, bloccando il motore degli oggetti. L'unico modo per risolvere questo problema è terminare forzatamente il processo e riavviare dal backup.

Per coloro che non lo sanno, il modo in cui funziona [Visual Works] Smalltalk è leggermente strano. È come un mini-OS. Quando avvii Smalltalk, carichi una "immagine di memoria" nella RAM e continua l'esecuzione da dove era stata interrotta. L'intero IDE Smalltalk è scritto in Smalltalk ed è modificabile dinamicamente.

In particolare, Smalltalkè un dizionario contenente tutte le variabili globali. In particolare, ogni volta che dichiari una nuova classe, viene creata una variabile globale con quel nome, che punta Classall'oggetto per la tua nuova classe. Quindi l'impostazione Smalltalksu Nil(sostanzialmente nulla) elimina tutte le classi dell'intero sistema. Persino i gestori di eventi della GUI diventano falsi.

Non ho idea del perché questa variabile sia persino scrivibile. Probabilmente perché è una variabile globale e quindi esiste come una voce al suo interno. (Ti fa ancora male la testa? Ho già detto che ogni oggetto ha una classe e che le classi sono oggetti, quindi ogni classe ha una classe? La classe di una classe è chiamata metaclasse, ma una metaclasse è anche un oggetto, che quindi ha una classe...)

Probabilmente potresti ottenere un effetto simile cancellando il dizionario anziché sostituendolo con null. In effetti, c'è un numero qualsiasi di cose che potresti codificare per eliminare tutte le classi nel sistema, lasciandoti incapace di fare qualsiasi cosa. Ma dal momento che l'attuale compilatore Smalltalk è anche una classe ... tutto ciò che rompe il linguaggio rompe un po 'l'intero IDE, quindi ...

Haskell

Ci sono un paio di possibilità qui.

Idea noiosa n. 1: definire maindi non fare nulla. Ora, indipendentemente dall'altro codice che scrivi, non potrà mai essere eseguito. (A meno che non venga eseguito manualmente dal REPL.)

Idea noiosa n. 2: definire un modulo senza esportazioni pubbliche. Ora, indipendentemente dall'altro codice che scrivi, non potrà mai essere eseguito.

Idea interessante: disabilitare tutte le importazioni.

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

Ora puoi definire funzioni che sono visibili e possono essere eseguite ... ma non possono fare nulla. Tutti i tipi e le funzioni standard di Haskell sono ora nascosti. (Con l'eccezione di alcune cose veramente profondamente cablate nella lingua.)

In particolare, non è possibile eseguire alcun I / O. Inoltre, non è possibile eseguire l'aritmetica di precisione della macchina. (Da allora Int, Doubleecc. Ora non sono definiti.)

È possibile ancora scrivere funzioni lambda-calcolo che eseguono qualche vera computazione però. Semplicemente non puoi ottenere alcun dato dentro o fuori dalla cosa. Ma potresti ovviamente scrivere un altro modulo separato che chiama il Fubarmodulo sopra e fa I / O per suo conto (dimostrando così che il codice viene eseguito e fa cose).

Alcune sottigliezze:

• La foo = foodichiarazione fittizia è necessaria per impedire a chiunque di aggiungere ulteriori importazioni. (Le importazioni non possono apparire dopo le dichiarazioni.)

• Esistono varie estensioni del linguaggio Haskell non standard che ti permetterebbero di uscire da questa situazione. Ma le estensioni di lingua devono essere attivate con un pragma di compilatore nella parte superiore del file. (O con un interruttore da riga di comando al compilatore. Non posso davvero impedirlo!)

PostScript

Sì, PostScript è un linguaggio di programmazione. Inoltre, è un linguaggio di programmazione in cui tutti i costrutti del linguaggio sono funzioni definite dal sistema, che possono essere ridefinite ...

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

In inglese:

• Crea un dizionario vuoto di 1.000 elementi e chiamalo Magic.
• Per ogni chiave in systemdict, aggiungi la stessa chiave a Magic, con una definizione vuota (" {}").
• Spingere Magicin cima allo stack del dizionario.

Da questo momento in poi, ogni comando in linguaggio PostScript è definito per non fare nulla. AFAIK, è impossibile sfuggire a questa condizione.

(Tecnicamente, non stai "distruggendo" le vecchie definizioni, le stai solo oscurando. Se potessi ancora eseguirle end, ciò eliminerebbe Magiclo stack del dizionario, annullando l'ombra di tutti i comandi e restituendoti la vita. Ma dal momento che endè anche in ombra ... non farà nulla ora.)

Nota che tutti i comandi verranno comunque eseguiti ... è solo che ora sono definiti per non fare nulla. Non otterrai alcun tipo di errore, è solo che non succederà nulla. (Beh, suppongo che alla fine succederà uno stack overflow ...)

Qualsiasi programma in esecuzione su Linux / x86 (-64)

Questo programma è scritto in C, ma può interrompere l'esecuzione di qualsiasi programma in esecuzione su Linux / x86 (-32 o -64). Si antepone all'invocazione della riga di comando del programma che si desidera interrompere.

Utilizza l'API di debugger per impedire al programma di destinazione di produrre alcun output. In particolare, tutte le chiamate di sistema in grado di comunicare qualcosa al mondo al di fuori del processo (ovviamente write, ovviamente, ma anche opendurante la creazione di un file, la maggior parte dell'API socket, killquando applicata a un altro processo, ...) fallirà come se non fossero stati implementati. _exitè consentito, ma il codice di uscita viene sovrascritto con uno zero.

A differenza della precedente edizione di questa risposta, molti programmi possono essere quasi completati in queste condizioni; è solo che tutto il loro lavoro è sprecato. Ad esempio, se lo fai ./no-syscalls /bin/ls(supponendo coreutils GNU ls) legge l'intera directory e la formatta, quindi tutte le writechiamate per produrre output falliscono. (Tutto ciò che deve aprire un canale di comunicazione bidirezionale, tuttavia, come tutti i client X11, fallirà a quel punto. Ho pensato di consentire socketma non send, ma mi è sembrato troppo probabile che si aprissero delle lacune.)

Esistono diverse opzioni della riga di comando per modificare il comportamento;

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

I programmi collegati dinamicamente non usciranno nemmeno dal linker dinamico in -emodalità. -Sovviamente apre un enorme buco nella politica, ma può essere divertente guardare i programmi lamentarsi di nulla che funzioni, ad es

$ ./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

Devi leggere l'output del registro con /usr/include/asm*/unistd.hopen in un'altra finestra, perché questo è già abbastanza lungo.

Sfortunatamente, le interfacce di debugger che utilizza sono solo debolmente coerenti tra le implementazioni Unix e sono intrinsecamente specifiche della CPU. Sarebbe relativamente semplice portarlo su altre architetture di CPU (basta aggiungere le definizioni appropriate di SYSCALL_*_REG), ed è probabilmente possibile portarlo su qualsiasi Unix che ha ptrace, ma potrebbe essere necessario confondersi con la whitelist di syscall ampiamente e occuparsi delle divergenze in 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));
    }
  }
}

TeX

\catcode`\\=10

Non sono sicuro che funzionerà davvero, ma in teoria questo dovrebbe rompersi \come personaggio di fuga che non ti lascia alcun modo per risolverlo. Normalmente TeX può leggere e scrivere file, ora non può scrivere nulla che dipenda dalla logica. Quindi la lingua è ora rotta come definita da OP.

EDIT: altri comandi kill presi dai commenti (sebbene entrambi possano violare la regola del codice da eseguire):

• \def\fi{}\iffalseda smpl crea un ramo if non chiudibile
• \catcode13=9%di iwillnotexist idonotexist crea un commento infinito

Graffiare

Il when [timer v] > (0)Correrò non appena il codice viene inizializzato, che se siete in l'editor è prima ancora di iniziare il codice. Questo when I receive (join[][])causerà un errore ogni volta che viene trasmesso qualcosa, mettendo in pausa l'esecuzione del codice se si dispone della versione per sviluppatori di Flash. La breakfunzione creerà cloni e attiverà l'errore di trasmissione. Ogni singolo clone durerà due secondi, quindi si eliminerà, mettendo a dura prova la pila. E ogni clone risponderà al when [timer v] > (0), eseguendo la breaksubroutine e resettando il timer, il che provoca nuovamente l'esecuzione del codice timer. Inoltre, ogni clone risponderà anche ad ogni errore di trasmissione, il che significa che il numero di errori per valutazione breakè il numero di cloni al quadrato. Ho dimenticato di menzionare che la breakfunzione harun without screen refreshcontrollato, causando il blocco, la scossa e il ritardo dell'editor, nonché la cattura e l'allocazione della memoria. E massimizzando la CPU.

Qualsiasi codice aggiunto ovunque con questa esecuzione non sarà in grado di creare cloni (superato il limite di 300 cloni) e di riscaldare e arrestare il computer che lo esegue. E catturare la memoria fino a quando non c'è più niente da afferrare, lasciando le variabili comportarsi male.

E, dopo che c'è troppo ritardo per attivare il when [timer v] > (0)blocco, sarà ancora in esecuzione break.

Grazie a @towerofnix per avermi ricordato il when I receiveproblema tecnico che ho trovato qualche tempo fa e per avermi dato l'idea run without screen refresh. Se ti è piaciuto, ecco l'originale: https://codegolf.stackexchange.com/a/61357/43394

Mathematica / Wolfram Language

Mathematica è un linguaggio interpretato in cui i nomi dei comandi sono simboli che possono essere manipolati dal programmatore. Non è possibile eliminare gli operatori integrati, ma è possibile sovraccaricarli o modificare in altro modo la loro funzione. Di seguito viene criptato il comando "Con", necessario per l'assegnazione alle variabili anche internamente. Questa modifica impedisce al kernel di trattenere argomenti non valutati fino al completamento dell'assegnazione, e uccide la lingua piuttosto morta.

ClearAttributes["With", HoldAll]

Se questo comando viene eseguito in una sessione interattiva o all'interno di un blocco di codice, Mathematica non sarà nemmeno in grado di aggiungere 1+1(il messaggio di errore risultante è lungo una pagina, quindi non lo includerò qui).

PHP

Sono sorpreso che funzioni davvero, ma chiudendo STDOUTe STDERRsopprimendo tutti gli output. Per essere sicuri che non verranno riaperti, apriamo /dev/nulltre volte per riassegnare i descrittori di file 0, 1 e 2:

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

// insert program here

Altre informazioni a riguardo: https://stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

Batch DOS (prima di Windows 95 credo)

CTTY

Rilasciato senza argomenti, questo disconnette la riga di comando dal terminale. Ogni ulteriore tentativo di leggere input o generare output non fa nulla.

Nel caso in cui volessi sapere come utilizzare CTTY correttamente:

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

Un file batch leggermente più potente potrebbe persino rispondere al modem e connettere qualsiasi cosa connessa a CTTY.

Lisp comune

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

Spero non abbiate bisogno di quelle parentesi aperte.

Questa è una macro del lettore che dice a Lisp Reader di sostituire ogni istanza di (con una chiamata a (lambda (x y) ()), una funzione che accetta due argomenti e non restituisce nulla. Quindi, ad esempio, leggerebbe (foo)come foo), interpretare foocome una variabile e quindi generare un errore di parentesi senza pari 0.

Graffiare

Ecco un esempio piuttosto semplice che bloccherà il tuo browser (e, in teoria, il tuo computer):

Ho lasciato questo in esecuzione per circa venti secondi, quindi ho perso 2,65 GB di memoria per Scratch. Solo un momento dopo e 5 GB erano spariti.

Consiglio vivamente di disporre di un mezzo per forzare l'uscita da Adobe Flash o dal browser Web prima di eseguire questo!

^{Volevo davvero fare una bella risposta come quella di clear(this)JS, ma purtroppo Scratch non ha modo di farlo. Sentiti libero di aggiornare questo post (o crearne uno tuo) se trovi un altro modo per rendere inutilizzabile Scratch!}

Thue

::=

Con una nuova riga alla fine

Il linguaggio thue si basa sulla definizione di set di regole e un ::=indica la fine del set di regole. E 'impossibile fare NULLA in Thue senza definire regole che lo fanno, quindi indipendentemente da ciò che si mette dopo il ::=, nulla può accadere.

Risposta alternativa

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

(e così via per ogni personaggio di tutto Unicode inclusi quelli precedenti al Apersonaggio e caratteri non stampabili). Ciò richiede l'opzione della riga di comando -r.

MATLAB

Il seguente codice rende l'ambiente completamente inutilizzabile ¹ :

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

Ciò sostituisce la builtinfunzione e la clearfunzione con nuovi handle di funzioni anonime che ritornano semplicemente falseogni volta che si tenta di chiamare queste funzioni. La builtinfunzione garantisce che se ci sono delle funzioni personalizzate che si scrivono in MATLAB che sono lo stesso nome di quelli che sono built-in a MATLAB (cose come sum, max, min, ecc), si è in grado di chiamare questi in modo inequivocabile al posto delle funzioni sovraccaricate . Allo stesso modo, clearti dà la possibilità di cancellare tutte le variabili che sono attualmente dichiarate in modo da poter ricominciare da capo. Rimuovendo queste funzionalità, non è possibile utilizzare MATLAB se non si riavvia il programma.

In MATLAB R2015a, ricevo anche il seguente messaggio:

L'area di lavoro sono le variabili attualmente dichiarate nell'ambiente in modo da poterle utilizzare in seguito. Ciò disabilita in modo permanente l'area di lavoro, quindi qualsiasi variabile che si tenta di creare non verrà salvata e quindi non è possibile fare progressi nell'esecuzione di righe di codice in MATLAB.

^{1: Il merito va all'utente Dev-iL che originariamente ha scoperto l'idea.}

///

/\///

L'unica operazione viene ripetuta /// sostituzione di stringhe, in questo modo: /pattern/replacement/.

Questo codice rimuove ogni /, in questo modo non è possibile utilizzare la sostituzione ripetuta di stringhe, quindi praticamente tutto ciò che scrivi dopo verrà stampato (tranne che per /s).

Puoi ancora usare \s, ma questo non ti aiuterà molto.

Befunge-96

'~h

Il codice dell'utente può seguire ovunque dopo questa sequenza, purché questi siano i primi tre caratteri nell'origine.

Il 'comando (modalità stringa one-shot) spinge il valore ASCII ~dello stack (ovvero 126), e hquindi imposta il cosiddetto delta olistico con quel valore. Per coloro che non hanno familiarità con Befunge-96, il Delta olistico è un offset che viene aggiunto al valore di ogni byte di comando che incontra l'interprete.

Una volta che il delta è impostato su 126, l'unico comando valido che può essere generato è ~(immissione caratteri), tramite un byte nullo nell'origine. Qualsiasi cosa diversa da un byte nullo si tradurrebbe in un valore maggiore di 126 e nessuno di questi valori sarebbe comandi Befunge validi.

Penso che sia sicuro affermare che ciò renderebbe inammissibile qualificarsi come linguaggio di programmazione.

fischio

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

E poi, da qualche altra parte nel progetto,

harmless

Una macro semplice con un nome dal suono innocuo, ma un effetto incredibilmente frustrante. Il compilatore Boo utilizza una pipeline multi-step che inizia con l'analisi del sorgente in un AST e termina con la generazione del codice. (Generalmente. Può essere riconfigurato per varie applicazioni.) Ogni passaggio intermedio esegue varie operazioni sull'AST.

A metà strada c'è la fase di espansione delle macro, in cui le macro vengono eseguite nel contesto del compilatore. Ricordi il bit nell'ultimo paragrafo, sulla riconfigurazione della pipeline? Se, durante l'espansione della macro, si richiama una macro che cancella la pipeline, l'utente non visualizzerà alcun errore, ma tutti i passaggi dopo l'espansione della macro (inclusa la generazione del codice) non sono più presenti. Quindi finisci con qualcosa che sembra una compilation riuscita - nessun messaggio di errore visualizzato - ma per qualche ragione non viene prodotto alcun binario! Garantito per guidare anche i migliori risoluzione dei problemi sul muro, se nascondi bene la macro e l'invocazione.

NGN / APL

NGN / APL consente di ridefinire le primitive, quindi ridefinire ( ←) tutte le funzioni primitive in ⊢("passare attraverso": entrambi ⊢3e 2⊢3dà 3) rende il linguaggio completamente inutile:

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

Provalo qui.

Ruby (29 caratteri)

class Object;def send;end;end

Poiché "send" viene utilizzato internamente ogni volta che viene chiamato un metodo all'interno di Ruby e poiché tutti gli oggetti ereditano dalla classe Object. Ciò dovrebbe impedire l'esecuzione di qualsiasi metodo.

Curiosità: questo è perfettamente sano in teoria. Ma sembra, per qualche motivo, non confondere la lingua di Ruby. Non ho idea del perché sia ​​possibile eseguire questo codice e quindi utilizzare ancora un ambiente Ruby aperto.

Tcl

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

Ciò rimuove tutte le parole chiave dalla lingua tranne ife rename.

Il codice sopra riportato causerebbe l'errore di qualsiasi nuovo codice. Quindi è discutibile se il nuovo codice inserito viene effettivamente "eseguito". Di seguito è una versione che esegue il nuovo codice ma non fa nulla perché cambia tutte le parole chiave (tranne ife proc) in una non-operazione:

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

Invece di eliminare le parole chiave questo codice le sostituisce con una funzione che non fa nulla.

(Nota: sto usando "parole chiave" molto vagamente qui perché Tcl non ha parole chiave, solo funzioni)

Hoon

=<  ~
(your code)

Hoon è strano. È praticamente completamente diverso dagli altri linguaggi di programmazione, non solo nella sintassi ma nella semantica. A differenza di linguaggi come Hexagony, tuttavia, non è stato fatto per essere intenzionalmente esoterico.

Hoon si compila in Nock , una VM basata su un minimo combinatore. Nock è stupido: le specifiche possono essere compresse a 340 byte. L'unica operazione matematica è l'incremento. Tutto è un sostantivo: un atomo (bignum) o una cellula (coppia di sostantivi), con l'intero modello di memoria disposto in un immutabile albero binario aciclico. L'unico output è il sostantivo a cui la tua espressione si riduce.

A causa dello strano obiettivo di compilazione, anche Hoon è strano: è completamente puro. Hoon si compila in un'espressione di Nock che viene valutata in un "contesto". L'intero kernel e stdlib, insieme a tutte le variabili, vengono passati implicitamente al programma dal contesto.

Per rendere inutilizzabile Hoon usiamo semplicemente =<"valutare a nel contesto di b". Valutiamo sempre ~, che è zero. Indipendentemente da ciò che bfa, non può cambiare il valore a cui si riduce e poiché non può avere effetti collaterali non può fare input o output.

Nota a margine: dal momento che non puoi effettivamente richiedere input da Hoon (purezza!), Secondo le regole non è in realtà un linguaggio di programmazione. L'input è tramite argomenti di funzione, output tramite valori di ritorno (o ~&, che è più una funzione di debug di printf ed è trasparente per il programma).

Affinché un programma ottenga input in Urbit, in realtà scrivi un programma che restituisce una funzione che accetta input e la shell chiede per tuo conto e passa al callback.

Taxi, 2354 byte.

Questo piccolo programma fa semplicemente funzionare il taxi in un grande joyride attraverso Townsburg, senza benzina. Qualsiasi codice che esegui dopo questo errore rapidamente con error: out of gas. E anche se potessi raggiungere una stazione di benzina, che non credo sia possibile, non potresti ottenere benzina, poiché non sono stati raccolti soldi, poiché non ci sono passeggeri.

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 nel browser

Bene, almeno in IE11.

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

Disabilita la scrittura nel documento, la scrittura nella variabile globale e il ritorno dalla funzione.

Commenta se ho perso un metodo di output!

Python 2, follemente grande

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

Questa folle quantità di codice è una rinascita del rexecmodulo antico (abbandonato in Python 2.3) con un mucchio di nuovi moduli aggiunti all'elenco "ok" e un mucchio di punti deboli risolti (incluso il object.__subclasses__()metodo che ha reso almeno altri due pitoni risposte non valide).

Un po 'di questo codice (il __init__metodo della RExecclasse e l'intera ModuleImporterclasse) viene copiato dalla libreria standard di Python con piccole modifiche.