Cobalah untuk menulis beberapa kode dalam bahasa Anda dan membuatnya tidak memenuhi kriteria kami sebagai bahasa pemrograman lagi.

Bahasa memenuhi kriteria kami (versi yang disederhanakan untuk tantangan ini) sebagai bahasa pemrograman jika:

• Itu dapat membaca input pengguna yang mewakili tupel bilangan bulat positif dalam beberapa cara.
• Ini dapat menghasilkan setidaknya dua hasil yang berbeda tergantung pada input.
• Ini dapat mengambil dua bilangan bulat positif dan menambahkannya (dan hasilnya dapat mempengaruhi output).
• Dapat mengambil bilangan bulat positif dan memutuskan apakah bilangan prima (dan hasilnya dapat mempengaruhi output).
• Untuk tujuan tantangan ini, segala jenis keluaran yang bukan merupakan metode keluaran yang diizinkan untuk tantangan normal diabaikan. Jadi tidak masalah apakah program tersebut juga dapat memainkan musik, atau memposting melalui HTTP, dll.
• Pembaruan: Anda juga dapat memilih satu atau beberapa metode output yang diizinkan, dan mengabaikan yang lainnya. Tetapi Anda harus menggunakan definisi yang sama di mana-mana dalam kriteria berikut. Dan jika program Anda dapat menonaktifkan lebih dari satu metode output - yang bernilai lebih banyak upvotes.

Contohnya seperti membuatnya tidak dapat menampilkan, atau menonaktifkan semua konstruksi loop sehingga tidak akan dapat melakukan uji coba awal dan memastikan pengguna tidak dapat mengaktifkannya kembali.

Anda harus meninggalkan tempat untuk memasukkan kode baru. Secara default, ini di akhir kode Anda. Jika kami mempertimbangkan untuk meletakkan kode sumber di tempat itu di jawaban Anda dan menjalankan kode lengkap sebagai program lengkap sebagai penerjemah bahasa baru, bahasa itu seharusnya tidak memenuhi kriteria.

Tetapi kode yang dimasukkan harus dieksekusi sedemikian rupa seperti bahasa yang memenuhi kriteria:

• Kode yang dimasukkan harus secara tata bahasa sama dengan sesuatu (katakan itu adalah blok kode dalam kriteria berikut) yang umumnya memenuhi kriteria, dari perspektif siapa pun yang ingin menulis stabilo sintaksis. Jadi tidak bisa dalam string, komentar, dll.
• Kode yang dimasukkan harus benar-benar dieksekusi, dengan cara yang seharusnya memenuhi kriteria. Jadi itu tidak bisa dalam fungsi yang tidak terpakai atau sizeofdi C, Anda tidak bisa hanya menjalankan bagian yang tidak berfungsi dalam kode, dan Anda tidak bisa meletakkannya setelah loop tak terbatas, dll.
• Anda tidak dapat membatasi jumlah program yang mungkin benar secara tata bahasa yang dihasilkan dengan cara ini. Jika sudah ada sesuatu seperti batas panjang dalam bahasa yang Anda gunakan, itu tidak akan memenuhi kriteria bahkan jika batas ini dihapus.
• Anda tidak dapat memodifikasi atau "menggunakan" konten input / output, tetapi Anda dapat mencegahnya diakses.
• Kriteria ini biasanya hanya berlaku untuk bahasa tanpa I / O eksplisit:
  • Kode Anda harus mengarahkan input pengguna (yang berisi informasi dengan panjang sewenang-wenang) ke kode yang dimasukkan, jika suatu blok kode biasanya tidak bisa mendapatkan input pengguna secara langsung / eksplisit dalam bahasa yang Anda gunakan.
  • Kode Anda harus mencetak nilai yang dikembalikan dari kode yang dimasukkan, jika blok kode biasanya tidak dapat menampilkan hal-hal secara langsung / eksplisit dalam bahasa yang Anda gunakan.
  • Jika Anda mencetak nilai yang dikembalikan, dan itu diketik dalam bahasa yang Anda gunakan, jenis yang dikembalikan harus dapat memiliki 2 nilai praktis yang mungkin berbeda. Misalnya, Anda tidak bisa menggunakan tipe struct {}atau struct {private:int x;}dalam C ++.

Ini adalah kontes popularitas. Jawaban sah terpilih tertinggi (jadi tidak ada yang melihat kesalahan atau semua kesalahan diperbaiki) menang.

Klarifikasi

• Anda tidak boleh memodifikasi kode dalam bentuk teks, tetapi dapat mengubah sintaksis sebelum kode ditafsirkan atau dikompilasi.
• Anda dapat melakukan hal-hal lain saat kode sedang berjalan. Tetapi alasan itu tidak memenuhi kriteria harus dalam kode yang dimasukkan itu sendiri. Itu dapat kesalahan karena gangguan dari utas lain, tetapi tidak hanya terbunuh oleh utas lain.
• Semua spesifikasi pada dasarnya berarti harus memenuhi kriteria secara tata bahasa jika semua built-in tidak diubah tetapi tidak benar-benar dilakukan. Tidak masalah jika Anda menemukan solusi non-gramatikal, seperti meneruskan parameter ke blok kode dengan benar, tetapi membuatnya tidak dapat digunakan dalam beberapa cara.
• Sekali lagi, kode yang dimasukkan harus benar-benar dieksekusi. Kode setelah infinite loop atau crashing dianggap "tidak benar-benar dieksekusi", sehingga tidak valid . Jawaban-jawaban itu mungkin menarik, tetapi sudah ada beberapa loop tak terbatas atau pertanyaan lain di situs ini, dan Anda mungkin menemukan jawaban yang lebih tepat untuk dijawab. Jika tidak, pertimbangkan untuk mengajukan pertanyaan baru. Contoh dari pertanyaan itu adalah:
  • Infinite loop terpendek yang tidak menghasilkan output
  • Mengapa ini tidak berakhir?
  • Loop tanpa 'looping'
  • Tantangan: Tulis sepotong kode yang berhenti sendiri
  • Kesalahan Runtime yang konyol
  • Hancurkan kompiler favorit Anda

Papan peringkat

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

Ini akan membuat bahasa tersebut benar-benar tidak dapat digunakan.

clear(this);

Bukankah menyenangkan JavaScript memiliki fungsi yang bagus untuk menghancurkan dirinya sendiri?

Ini cukup sederhana, clearfungsinya benar-benar mengosongkan objek. thismengacu pada objek global yang membersihkan segala sesuatu termasuk konstruktor dan fungsi.

Karena ini membersihkan semuanya , melakukan apa saja , bahkan mendefinisikan literal akan membuat kesalahan, membuat bahasa tersebut sama sekali tidak berguna: _{* Lingkungan REPL tidak diperlukan. Menggunakan mesin SpiderMonkey (shell not browser), mesin JS asli.}

Emmental

;#33!

Saya tahu ini bukan kode golf, tetapi alat yang tepat untuk pekerjaan itu, Anda tahu ...

Kode pengguna dapat dimasukkan setelah !.

Emmental adalah esolang yang menarik yang didasarkan pada penulisan ulang penerjemah. Setiap simbol tunggal (termasuk simbol bawaan) dapat didefinisikan ulang sebagai program Emmental yang sewenang-wenang. Bahasa ini sangat bergantung pada fitur ini sehingga tidak menyediakan konstruksi perulangan. Sebagai gantinya, Anda mendefinisikan perintah rekursif yang muncul dalam definisi mereka sendiri.

Redefinisi ini terjadi via !, yang membaca karakter dari stack, dan kemudian membaca string dari stack hingga bertemu dengan a ;. Karakter kemudian didefinisikan ulang untuk berarti program yang diwakili oleh string itu.

Itu artinya, kita dapat menonaktifkan fitur looping Emmental dengan mendefinisikan kembali ! dirinya sebagai program kosong. Sementara semua kode Emmental lainnya masih berjalan dengan baik, dan banyak kriteria bahasa pemrograman masih terpenuhi, tidak mungkin untuk mendefinisikan kembali simbol lagi. Tanpa fitur ini (dan karenanya, tanpa dapat mengulang), Emmental tidak dapat lagi menguji apakah suatu bilangan prima.

PHP

Satu dapat sepenuhnya membunuh PHP dengan menetapkan batas memori ke 1.

Itu akan benar-benar mati.

Coba ini:

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

    //code here

Ini seharusnya tidak membuat kesalahan, karena tidak ada cukup memori untuk itu.

Anda dapat membaca lebih lanjut tentang memory_limitarahan

Jika yang sebelumnya tidak valid, seseorang dapat menggunakan buffer output:

<?php
    ob_start();

    //code here

    ob_clear();

Ini sepenuhnya menghilangkan output apa pun. Karena buffer output masih terbuka, beberapa hal lain tidak sengaja tersisa setelah kode tidak akan ditampilkan juga.

Menggunakan ide @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();

Ini akan menghindari masalah menghapus buffer output yang dimulai secara otomatis, yang digunakan untuk menangkap output yang akan dikompresi.

Ini juga mencegah buffer output dihapus atau dihapus (dikirim ke browser). Untuk memperkuat kembali hal itu, penangan keluaran ditambahkan, yang selalu mengembalikan string kosong.
Menjalankan ob_end_flush(); echo "Hello, world!";tidak akan menghasilkan apa-apa, tetapi akan mengirimkan output dengan polos ob_start();.

Terima kasih kepada @LucasTrzesniewski karena mengungkap masalah ini!

kode mesin x86 dalam mode real (=> hampir semua program DOS)

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

yaitu

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

Saya harap Anda tidak terlalu terikat dengan tabel interrupt Anda.

Jawa

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

Sunting: Penanggulangan balasan membuat raksasa ini :(

Arahkan ulang stdin dan stdout ke null stream dan ganti args dengan array kosong. Juga menggunakan retasan refleksi dalam jumlah besar untuk memastikan IO standar benar-benar tersembunyi. Akhirnya, ini menetapkan manajer keamanan untuk memastikan standar IO tidak dapat diciptakan kembali dan yang memastikan program tidak dapat mengatur kode keluar.

Lua

_ENV=""

Dalam Lua, _ENVadalah lingkungan di mana semua variabel global, fungsi, tabel, dll disimpan. Mendefinisikannya hanya sebagai string kosong berarti Anda tidak dapat menentukan apa pun yang baru, dan semua fungsi dan variabel dihapus. Ini berarti Anda tidak dapat menampilkan apa pun, menerima masukan, atau melakukan apa saja.

Bahasa Pemrograman 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]

Dalam SPL, parser bawaan yang diunduh bersama program mengikuti aturan yang sangat spesifik tentang apa yang bisa terjadi dalam skrip. Salah satu aturan tersebut adalah bahwa hanya dua karakter yang dapat berada di panggung sekaligus. Juga, membuat karakter keluar dari panggung yang tidak pernah di atas panggung akan membingungkannya. Hal yang sama berlaku untuk menambahkan karakter ke panggung yang sudah ada di panggung. Ketika parser menerima kesalahan, ia akan menolak untuk melakukan hal lain; Anda benar-benar harus sepenuhnya mematikan program dan parser dan kemudian memulai semuanya lagi.

PS Jika Anda tidak tahu bagaimana bahasa ini bekerja, Google itu. Itu mengagumkan.

Smalltalk

Saya tidak yakin apakah ini memenuhi syarat:

Smalltalk := Nil.

Ini menghapus seluruh lingkungan run-time, menggantung mesin objek. Satu-satunya cara untuk memperbaikinya adalah dengan menghentikan proses secara paksa dan memulai kembali dari cadangan.

Bagi mereka yang tidak tahu, cara [Visual Bekerja] Smalltalk bekerja agak aneh. Ini seperti mini-OS. Ketika Anda memulai Smalltalk, Anda memuat "memori gambar" ke dalam RAM, dan itu melanjutkan mengeksekusi dari tempat itu tinggalkan. Seluruh Smalltalk IDE ditulis dalam Smalltalk dan dapat dimodifikasi secara dinamis.

Secara khusus, Smalltalkadalah kamus yang berisi semua variabel global. Terutama, setiap kali Anda mendeklarasikan kelas baru, variabel global dengan nama itu dibuat, menunjuk ke Classobjek untuk kelas baru Anda. Jadi pengaturan Smalltalkke Nil(pada dasarnya nol) menghapus semua kelas di seluruh sistem. Bahkan penangan acara GUI pun pudar.

Saya tidak tahu mengapa variabel ini bahkan dapat ditulis. Mungkin karena itu adalah variabel global, dan karenanya ada sebagai entri di dalam dirinya sendiri. (Apakah kepala Anda belum terluka? Apakah saya menyebutkan bahwa setiap objek memiliki kelas, dan kelas adalah objek, sehingga setiap kelas memiliki kelas? Kelas kelas disebut metaclass, tetapi metaclass juga merupakan objek, yang karenanya memiliki kelas...)

Anda mungkin dapat mencapai efek serupa dengan membersihkan kamus daripada menggantinya dengan nol. Memang, ada sejumlah hal yang dapat Anda kode untuk menghapus semua kelas dalam sistem, membuat Anda tidak dapat melakukan apa pun. Tetapi karena kompiler Smalltalk yang sebenarnya juga merupakan kelas ... apa pun yang merusak bahasa juga agak merusak seluruh IDE, jadi ...

Haskell

Ada beberapa kemungkinan di sini.

Ide membosankan # 1: Tetapkan mainuntuk tidak melakukan apa-apa. Sekarang apa pun kode lain yang Anda tulis, itu tidak akan pernah bisa dijalankan. (Kecuali jika Anda menjalankannya secara manual dari REPL.)

Ide membosankan # 2: Tentukan modul tanpa ekspor publik. Sekarang, apa pun kode yang Anda tulis, itu tidak akan pernah bisa dieksekusi.

Ide menarik: Nonaktifkan semua impor.

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

Sekarang Anda dapat menentukan fungsi yang sangat terlihat dan dapat dijalankan ... tetapi mereka tidak bisa berbuat apa-apa. Semua tipe dan fungsi Haskell standar sekarang disembunyikan. (Dengan pengecualian beberapa hal yang benar -benar terprogram ke dalam bahasa.)

Terutama, Anda tidak dapat melakukan I / O apa pun. Anda juga tidak dapat melakukan aritmatika presisi mesin. (Karena Int,, Doubledll sekarang tidak ditentukan.)

Anda masih dapat menulis fungsi lambda-calculus yang melakukan beberapa perhitungan nyata. Anda tidak bisa mendapatkan data apa pun masuk atau keluar dari hal itu. Tetapi Anda tentu saja dapat menulis modul lain yang terpisah yang memanggil Fubarmodul di atas dan melakukan I / O atas namanya (dengan demikian membuktikan bahwa kode tersebut mengeksekusi dan melakukan hal-hal).

Beberapa seluk-beluk:

• foo = fooDeklarasi dummy diperlukan untuk mencegah orang menambahkan impor tambahan. (Impor tidak dapat muncul setelah deklarasi.)

• Ada berbagai ekstensi bahasa Haskell non-standar yang memungkinkan Anda keluar dari situasi ini. Tetapi ekstensi bahasa harus diaktifkan dengan pragma kompiler di bagian atas file. (Atau dengan saklar baris perintah ke kompiler. Saya tidak bisa mencegahnya!)

Nota bene

Ya, PostScript adalah bahasa pemrograman. Selain itu, ini adalah bahasa pemrograman di mana semua konstruksi bahasa adalah fungsi yang ditentukan sistem, yang dapat didefinisikan ulang ...

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

Dalam Bahasa Inggris:

• Buat kamus 1.000 elemen kosong dan beri nama Magic.
• Untuk setiap kunci systemdict, tambahkan kunci yang sama ke Magic, dengan definisi kosong (" {}").
• Tekan Magicke atas tumpukan kamus.

Sejak saat ini, setiap perintah bahasa PostScript didefinisikan untuk tidak melakukan apa pun. AFAIK, tidak mungkin untuk melarikan diri dari kondisi ini.

(Secara teknis, Anda tidak "menghancurkan" definisi lama, Anda hanya membayangi definisi itu. Jika Anda masih bisa mengeksekusi end, itu akan Magicmengeluarkan tumpukan kamus, membatalkan semua perintah dan mengembalikan hidup Anda. Tetapi karena enditu sendiri juga dibayangi ... itu tidak akan melakukan apa pun sekarang.)

Perhatikan bahwa semua perintah masih akan menjalankan ... Hanya saja sekarang mereka didefinisikan untuk tidak melakukan apa pun. Anda tidak akan mendapatkan kesalahan apa pun, hanya saja tidak ada yang terjadi. (Yah, saya kira stack overflow akan terjadi pada akhirnya ...)

Semua program yang dijalankan di Linux / x86 (-64)

Program ini ditulis dalam C, tetapi dapat mengganggu pelaksanaan program yang berjalan di Linux / x86 (-32 atau -64). Anda menambahkannya ke pemanggilan baris perintah dari program yang ingin Anda ganggu.

Ini menggunakan API debugger untuk mencegah program target menghasilkan output apa pun. Secara khusus, semua panggilan sistem yang dapat mengkomunikasikan sesuatu kepada dunia di luar proses (yang paling jelas write, tentu saja, tetapi juga opensaat membuat file, sebagian besar API soket, killbila diterapkan ke proses lain, ...) akan gagal seolah-olah mereka tidak diimplementasikan. _exitdiperbolehkan, tetapi kode keluar ditimpa dengan nol.

Berbeda dengan edisi sebelumnya dari jawaban ini, banyak program dapat berjalan hampir selesai dalam kondisi ini; hanya saja semua pekerjaan mereka sia-sia. Sebagai contoh, jika Anda melakukannya ./no-syscalls /bin/ls(dengan asumsi GNU coreutils ls), ia membaca seluruh direktori dan memformatnya, dan kemudian semua writepanggilan untuk menghasilkan output gagal. (Apa pun yang perlu membuka saluran komunikasi dua arah, meskipun, seperti semua klien X11, akan gagal pada saat itu. Saya berpikir untuk mengizinkan sockettetapi tidak send, tetapi sepertinya terlalu mungkin untuk membuka celah.)

Ada beberapa opsi baris perintah untuk mengubah perilaku;

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

Program yang terhubung secara dinamis bahkan tidak akan keluar dari tautan dinamis dalam -emode. -Sjelas membuka lubang besar dalam kebijakan, tetapi bisa menghibur untuk menonton program mengeluh tentang tidak ada yang bekerja, misalnya

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

Anda harus membaca keluaran log dengan /usr/include/asm*/unistd.hterbuka di jendela lain, karena ini sudah cukup lama.

Sayangnya, antarmuka debugger yang digunakan ini hanya sedikit konsisten di seluruh implementasi Unix, dan secara intrinsik spesifik CPU. Akan relatif mudah untuk mem-port-nya ke arsitektur CPU lain (cukup tambahkan definisi yang sesuai SYSCALL_*_REG), dan mungkin memungkinkan untuk mem-port-kannya ke Unix apa pun yang ada ptrace, tetapi Anda mungkin perlu muck dengan daftar putih syscall secara ekstensif dan juga berurusan dengan divergensi di 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

Saya tidak yakin ini benar-benar berfungsi, tetapi secara teori ini seharusnya pecah \sebagai karakter pelarian sehingga Anda tidak dapat memperbaikinya. Biasanya TeX dapat membaca dan menulis file, sekarang tidak dapat menulis apa pun yang tergantung pada logika. Dengan demikian bahasa sekarang rusak sebagaimana didefinisikan oleh OP.

EDIT: Perintah kill lain yang diambil dari komentar (meskipun keduanya mungkin melanggar aturan kode-harus-dieksekusi):

• \def\fi{}\iffalseoleh smpl membuat cabang if-closable
• \catcode13=9%oleh iwillnotexist idonotexist menciptakan komentar yang tidak pernah berakhir

Menggaruk

Ini when [timer v] > (0)akan berjalan segera setelah kode diinisialisasi, yang jika Anda berada di editor bahkan sebelum Anda memulai kode. Ini when I receive (join[][])akan menyebabkan kesalahan untuk dilemparkan setiap kali sesuatu disiarkan, menghentikan eksekusi kode jika Anda memiliki versi Flash pengembang. The breakfungsi akan membuat klon, dan memicu kesalahan siaran. Setiap satu klon akan bertahan dua detik kemudian menghapus dirinya sendiri, menempatkan ketegangan pada tumpukan. Dan setiap klon akan merespons when [timer v] > (0), menjalankan breaksubrutin dan mengatur ulang timer, yang menyebabkan kode timer dijalankan lagi. Selain itu, setiap klon akan merespons setiap kesalahan siaran juga, yang berarti jumlah kesalahan per evaluasi breakadalah jumlah klon yang dikuadratkan. Apakah saya lupa menyebutkan bahwa breakfungsi telahrun without screen refreshdicentang, menyebabkan editor membeku, tersentak dan ketinggalan, serta mengambil dan mengalokasikan memori. Dan memaksimalkan CPU.

Kode apa pun yang ditambahkan di mana saja dengan menjalankan ini akan mendapati dirinya tidak dapat membuat klon (melampaui batas 300 klon) serta memanaskan dan membuat crash komputer yang menjalankannya. Dan mengambil memori sampai tidak ada lagi yang bisa diambil, meninggalkan variabel yang tidak sesuai.

Dan, setelah ada terlalu banyak jeda untuk memicu when [timer v] > (0)blok, itu masih akan berjalan break.

Terima kasih kepada @towerofnix untuk mengingatkan saya tentang when I receivekesalahan yang saya temukan beberapa waktu lalu, dan memberi saya ide untuk itu run without screen refresh. Jika Anda menyukai ini, inilah aslinya: https://codegolf.stackexchange.com/a/61357/43394

Bahasa Mathematica / Wolfram

Mathematica adalah bahasa yang ditafsirkan di mana nama perintah adalah simbol yang dapat dimanipulasi oleh programmer. Anda tidak bisa menghapus operator bawaan, tetapi Anda bisa membebani mereka atau memodifikasi fungsinya. Berikut ini mengacak perintah "Dengan", yang diperlukan untuk penugasan ke variabel bahkan secara internal. Perubahan ini mencegah kernel dari menahan argumen tidak dievaluasi sampai tugas selesai, dan itu membunuh bahasa cukup mati.

ClearAttributes["With", HoldAll]

Jika perintah ini dijalankan dalam sesi interaktif atau dalam blok kode, Mathematica bahkan tidak akan dapat menambahkan 1+1(pesan kesalahan yang dihasilkan adalah sekitar satu halaman sehingga saya tidak akan memasukkannya di sini).

PHP

Saya terkejut bahwa itu benar-benar berfungsi, tetapi menutup STDOUTdan STDERRmenekan semua output. Untuk memastikan bahwa mereka tidak akan dibuka lagi, kami membuka /dev/nulltiga kali untuk menetapkan kembali file deskriptor 0, 1 dan 2:

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

// insert program here

Lebih lanjut tentang itu: https://stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

Batch DOS (sebelum Windows 95 saya percaya)

CTTY

Dikeluarkan tanpa argumen, ini memutus baris perintah dari terminal. Upaya lebih lanjut untuk membaca input atau menghasilkan output tidak melakukan apa-apa.

Jika Anda ingin tahu cara menggunakan CTTY dengan benar:

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

File batch yang sedikit lebih kuat bahkan bisa menjawab modem dan menghubungkan apa pun yang dipanggil ke CTTY.

Gangguan umum

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

Saya harap Anda tidak membutuhkan kurung pembuka itu.

Ini adalah makro pembaca yang memberi tahu Lisp Reader untuk mengganti setiap instance (dengan panggilan (lambda (x y) ()), fungsi yang mengambil dua argumen dan tidak mengembalikan apa pun. Jadi, misalnya, itu akan dibaca (foo)sebagai foo), ditafsirkan foosebagai variabel dan kemudian melempar kesalahan kurung yang tak tertandingi 0.

Menggaruk

Berikut adalah contoh yang cukup sederhana yang akan membuat browser Anda macet (dan, secara teori, komputer Anda):

Saya membiarkan ini berjalan sekitar dua puluh detik, kemudian kehilangan 2,65 GB memori untuk Scratch. Hanya sesaat kemudian dan 5 GB hilang.

Saya sangat menyarankan Anda memiliki cara untuk memaksa berhenti Adobe Flash atau browser web Anda sebelum menjalankan ini!

^{Saya benar - benar ingin membuat jawaban yang keren seperti clear(this)JS tetapi sayangnya Scratch tidak punya cara untuk melakukan itu. Jangan ragu untuk memperbarui posting ini (atau buat posting Anda sendiri) jika Anda TIDAK menemukan cara lain untuk membuat Scratch tidak dapat digunakan lagi!}

Itu

::=

Dengan baris baru di akhir

Bahasa thue bergantung pada mendefinisikan aturan dan a ::=menunjukkan akhir aturan. Tidak mungkin untuk melakukan APA SAJA di dalam tanpa mendefinisikan aturan yang melakukannya, jadi terlepas dari apa yang Anda masukkan setelah itu ::=, tidak ada yang bisa terjadi.

Jawaban alternatif

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

(dan seterusnya untuk setiap karakter di semua Unicode termasuk yang sebelum Akarakter dan karakter yang tidak dapat dicetak). Ini membutuhkan opsi baris perintah -r.

MATLAB

Sepotong kode berikut membuat lingkungan benar-benar tidak dapat digunakan ¹ :

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

Ini menimpa builtinfungsi dan clearfungsi dengan pegangan fungsi anonim baru yang hanya kembali falsesetiap kali Anda mencoba dan memanggil fungsi-fungsi ini. The builtinfungsi memastikan bahwa jika ada fungsi kustom yang Anda tulis di MATLAB yang merupakan nama yang sama dengan mereka yang built-in untuk MATLAB (hal-hal seperti sum, max, min, dll), Anda dapat menyebut tegas bukan fungsi kelebihan beban . Demikian pula,clear memberi Anda kemampuan untuk menghapus semua variabel yang saat ini dideklarasikan sehingga Anda dapat memulai baru. Dengan menghapus kapabilitas ini, Anda tidak dapat menggunakan MATLAB kecuali Anda me-restart program.

Di MATLAB R2015a, saya juga mendapatkan pesan berikut:

Workspace adalah variabel yang saat ini dideklarasikan di lingkungan sehingga Anda dapat menggunakannya untuk nanti. Ini secara permanen menonaktifkan Workspace, jadi variabel apa pun yang Anda coba dan buat tidak akan disimpan dan karenanya tidak ada kemajuan yang dapat dibuat ketika menjalankan baris kode di MATLAB.

^{1: Kredit diberikan kepada pengguna Dev-iL yang awalnya menemukan ide tersebut.}

///

/\///

Satu-satunya operasi di /// adalah penggantian string berulang, seperti ini: /pattern/replacement/ .

Kode ini menghapus setiap /, dengan cara itu Anda tidak dapat menggunakan substitusi string berulang, jadi pada dasarnya semua yang Anda tulis setelah itu akan dicetak (kecuali untuk/ s).

Anda masih dapat menggunakan \s, tetapi itu tidak banyak membantu Anda.

Befunge-96

'~h

Kode pengguna dapat mengikuti di mana saja setelah urutan ini, selama ini adalah tiga karakter pertama dalam sumber.

The 'perintah (modus tali satu-shot) mendorong nilai ASCII dari ~ke stack (yaitu 126), dan hperintah kemudian menetapkan apa yang dikenal sebagai Delta Holistik dengan nilai tersebut. Bagi mereka yang tidak terbiasa dengan Befunge-96, itu Delta Holistik adalah offset yang ditambahkan ke nilai setiap byte perintah yang ditemui juru bahasa.

Setelah delta diatur ke 126, satu-satunya perintah yang valid yang dapat dihasilkan adalah ~ (input karakter), melalui byte nol di sumbernya. Apa pun selain byte nol akan menerjemahkan ke nilai yang lebih besar dari 126, dan tidak satu pun dari nilai-nilai itu akan menjadi perintah Befunge yang valid.

Saya pikir aman untuk mengatakan bahwa ini akan membuatnya tidak memenuhi syarat untuk memenuhi syarat sebagai bahasa pemrograman.

Boo

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

Dan kemudian, di tempat lain dalam proyek ini,

harmless

Makro sederhana dengan nama yang terdengar tidak berbahaya, tetapi efek yang luar biasa membuat frustrasi. Kompiler Boo menggunakan pipa multi-langkah yang dimulai dengan parsing source ke AST dan diakhiri dengan pembuatan kode. (Umumnya. Dapat dikonfigurasi ulang untuk berbagai aplikasi.) Setiap langkah di antaranya melakukan berbagai operasi di AST.

Partway through adalah tahap ekspansi makro, di mana makro dieksekusi dalam konteks kompiler. Ingat sedikit pada paragraf terakhir, tentang pipa yang dapat dikonfigurasi ulang? Jika, selama ekspansi makro, Anda menjalankan makro yang membersihkan pipa, tidak ada kesalahan akan ditampilkan kepada pengguna, tetapi semua langkah setelah ekspansi makro (termasuk pembuatan kode) tidak lagi ada. Jadi Anda berakhir dengan sesuatu yang terlihat seperti kompilasi yang berhasil - tidak ada pesan kesalahan yang ditampilkan - tetapi untuk beberapa alasan tidak ada biner yang dihasilkan! Dijamin untuk mendorong bahkan pemecah masalah terbaik di dinding, jika Anda menyembunyikan makro dan doa dengan baik.

NGN / APL

NGN / APL memungkinkan mendefinisikan ulang primitif, jadi mendefinisikan ulang ( ←) semua fungsi primitif untuk ⊢("melewati": keduanya ⊢3dan 2⊢3memberi 3) membuat bahasa tersebut sama sekali tidak berguna:

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

Coba di sini.

Ruby (29 karakter)

class Object;def send;end;end

As 'send' digunakan secara internal setiap kali sebuah metode dipanggil dalam Ruby, dan karena semua objek mewarisi dari kelas Object. Ini harus menghentikan metode apa pun yang sedang dijalankan.

Fakta Menarik: Ini sangat sesuai dengan teori. Tapi tampaknya, untuk beberapa alasan, tidak pincang bahasa Ruby. Saya tidak tahu mengapa mungkin menjalankan kode ini dan kemudian masih menggunakan lingkungan Ruby terbuka.

Tcl

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

Ini menghapus semua kata kunci dari bahasa kecuali ifdanrename .

Kode di atas akan menyebabkan kesalahan kode baru. Jadi masih bisa diperdebatkan jika kode yang baru dimasukkan benar-benar "dieksekusi". Di bawah ini adalah versi yang mengeksekusi kode baru tetapi tidak melakukan apa-apa karena itu mengubah semua kata kunci (kecuali ifdan proc) menjadi tidak ada operasi:

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

Alih-alih menghapus kata kunci, kode ini menggantikannya dengan fungsi yang tidak menghasilkan apa-apa.

(Catatan: Saya menggunakan "kata kunci" dengan sangat longgar di sini karena Tcl tidak memiliki kata kunci, hanya fungsi)

Hoon

=<  ~
(your code)

Hoon aneh. Sama sekali tidak seperti bahasa pemrograman lain, tidak hanya dalam sintaksis tetapi juga dalam semantik. Tidak seperti bahasa-bahasa seperti Hexagony, itu tidak sengaja dibuat menjadi esoteris.

Hoon mengkompilasi ke Nock , VM berbasis kombinator minimal. Nock itu bodoh: specnya bisa di-gzip hingga 340 byte. Satu-satunya operasi matematika adalah peningkatan. Semuanya adalah kata benda: atom (bignum) atau sel (sepasang kata benda), dengan seluruh model memori disusun dalam pohon biner asiklik yang tidak dapat diubah. Satu-satunya output adalah kata benda yang mengurangi ekspresi Anda.

Karena target kompilasi yang aneh, Hoon juga aneh: itu benar-benar murni. Hoon mengkompilasi ke ekspresi Nock yang dievaluasi pada "konteks". Seluruh kernel dan stdlib, bersama dengan semua variabel, diteruskan secara implisit ke program oleh konteksnya.

Untuk membuat Hoon tidak dapat digunakan, kami hanya menggunakan =<, yaitu "mengevaluasi a dalam konteks b". Kami selalu mengevaluasi ~, yaitu nol. Apa pun yang bterjadi, itu tidak dapat mengubah nilai yang direduksinya, dan karena tidak dapat memiliki efek samping, ia tidak dapat melakukan input atau output.

Catatan: Karena Anda tidak dapat benar-benar meminta input dari Hoon (murni!), Menurut aturan, itu sebenarnya bukan bahasa pemrograman. Input adalah melalui argumen fungsi, output melalui nilai balik (atau~& , yang lebih merupakan fitur debugging printf dan transparan untuk program).

Agar suatu program mendapatkan input dalam Urbit, Anda sebenarnya menulis sebuah program yang mengembalikan fungsi yang menerima input, dan shell menanyakan atas nama Anda dan meneruskan ke callback.

Taksi, 2354 byte.

Program kecil ini hanya menjalankan taksi dalam sukacita besar melalui Townsburg, kehabisan bensin. Kode apa pun yang Anda jalankan setelah ini akan dengan cepat kesalahan error: out of gas. Dan bahkan jika Anda bisa mencapai pompa bensin, yang saya pikir tidak mungkin, Anda tidak bisa mendapatkan bensin, karena tidak ada uang yang dikumpulkan, karena tidak ada penumpang.

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

Yah, setidaknya di IE11.

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

Menonaktifkan penulisan ke dokumen, menulis ke variabel global dan kembali dari fungsi.

Komentari jika saya melewatkan metode keluaran!

Python 2, sangat besar

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

Jumlah besar kode ini adalah kebangkitan rexecmodul kuno (ditinggalkan dengan python 2.3) dengan banyak modul baru ditambahkan ke daftar "ok" dan banyak kelemahan diperbaiki (termasukobject.__subclasses__() metode yang telah membuat setidaknya dua python lain jawaban tidak valid).

Cukup banyak kode ini ( __init__metode RExeckelas dan seluruh ModuleImporterkelas) disalin dari pustaka standar python dengan modifikasi kecil.