あなたの言語でコードを書き、プログラミング言語であるという基準をもはや満たさないようにしてください。

言語は、次の場合にプログラミング言語であるという基準（この課題の簡略版）を満たします。

• 何らかの方法で正の整数のタプルを表すユーザー入力を読み取ることができます。
• 入力に応じて、少なくとも2つの異なる結果を出力できます。
• 2つの正の整数を取り、それらを追加できます（結果は出力に影響する可能性があります）。
• 正の整数を取り、それが素数であるかどうかを判断できます（結果は出力に影響する可能性があります）。
• このチャレンジの目的上、通常のチャレンジで許可されている出力方法ではない出力は無視されます。そのため、プログラムで音楽を再生したり、HTTP経由で投稿したりできるかどうかは関係ありません。
• 更新：許可された出力方法の1つまたはいくつかを選択し、他のすべてを無視することもできます。ただし、次の基準ではどこでも同じ定義を使用する必要があります。また、プログラムで複数の出力メソッドを無効にできる場合は、さらに価値があります。

出力できないようにする、またはすべてのループ構造を無効にして素数テストを実行できないようにし、ユーザーがそれらを再度有効にできないようにするなどの例。

新しいコードを挿入する場所を残す必要があります。デフォルトでは、コードの最後にあります。回答のソースコードをその場所に配置し、完全なコードを新しい言語のインタープリターとして完全なプログラムとして実行することを検討する場合、その言語は基準を満たさないはずです。

ただし、挿入されたコードは、基準を満たす言語のような方法で実行する必要があります。

• 挿入されたコードは、構文ハイライターを作成したい人の観点から、一般的に基準を満たしているもの（たとえば、次の基準のコードブロック）と文法的に同じでなければなりません。そのため、文字列、コメントなどに含めることはできません。
• 挿入されたコードは、基準を満たすように実際に実行する必要があります。したがって、未使用の関数やsizeofCに含めることはできません。コード内の非機能部分のみを実行することはできません。また、無限ループなどに配置することもできません。
• この方法で生成される文法的に正しいプログラムの数を制限することはできません。使用している言語に既に長さ制限のようなものがある場合、この制限が削除されても、基準を満たさないはずです。
• 入力/出力の内容を変更または「使い切る」ことはできませんが、アクセスを防ぐことができます。
• これらの基準は通常、明示的なI / Oのない言語にのみ適用されます。
  • コードブロックは通常、使用している言語で直接/明示的にユーザー入力を取得できない場合、ユーザー入力（任意の長さの情報を含む）を挿入されたコードにリダイレクトする必要があります。
  • コードは通常、使用している言語で直接/明示的に物を出力できない場合、挿入されたコードの戻り値を出力する必要があります。
  • 返された値を印刷し、使用している言語で入力された場合、返された型は実際に可能な2つの異なる値を持つことができるはずです。たとえば、タイプstruct {}またはstruct {private:int x;}C ++では使用できません。

これは人気コンテストです。最も高い投票された有効な回答（だから誰もエラーを見つけなかったか、すべてのエラーが修正された）が勝ちです。

明確化

• テキスト形式のコードは変更しないでくださいが、コードが解釈またはコンパイルされる前に構文を変更できます。
• コードの実行中に他のことを行うことができます。しかし、それが基準を満たさない理由は、挿入されたコード自体の中にあるべきです。別のスレッドの干渉が原因でエラーになる可能性がありますが、別のスレッドに殺されるだけではありません。
• すべての仕様は基本的に、すべての組み込みが変更されていないが実際に変更されていない場合、文法的に基準を満たす可能性が高いことを意味します。パラメータをコードブロックに正しく渡すなど、文法的ではない回避策を見つけても、何らかの方法で使用できないようにするのは問題ありません。
• 繰り返しますが、挿入されたコードは実際に実行する必要があります。無限ループまたはクラッシュ後のコードは「実際には実行されていない」と見なされるため、有効ではありません。これらの回答は興味深いかもしれませんが、このサイトにはすでに他の無限ループまたはクラッシュする質問がいくつかあり、回答するのにより適切なものを見つけることができます。そうでない場合は、新しい質問をすることを検討してください。それらの質問の例は次のとおりです。
  • 出力を生成しない最短無限ループ
  • なぜ終わらないのですか？
  • 「ループ」なしのループ
  • 課題：終了するコードを書く
  • とんでもないランタイムエラー
  • お気に入りのコンパイラをクラッシュさせる

リーダーボード

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シェル

これにより、言語が完全に使用できなくなります。

clear(this);

JavaScriptがそれ自体を破壊するような素晴らしい機能を持っているのは素晴らしいことではありませんか？

これは非常に簡単で、clear関数はオブジェクトを完全に空にします。コンストラクターや関数を含むすべてをthisクリアするグローバルオブジェクトを指します。

これはすべてをクリアし、何でもして、リテラルを定義することさえエラーをスローするので、言語は完全に役に立たなくなります： _{* REPL環境は必要ありません。元のJSエンジンであるSpiderMonkeyエンジン（ブラウザーではなくシェル）を使用します。}

エメンタール

;#33!

私はこれがゴルフのコードではないことを知っていますが、仕事に最適なツールです。

ユーザーのコードはの後に挿入できます!。

エメンタールは、インタプリタの書き換えに基づいた興味深いエソランです。すべての単一のシンボル（組み込みのシンボルを含む）は、任意のEmmentalプログラムとして再定義できます。この言語はこの機能に大きく依存しているため、ループ構造は提供されません。代わりに、独自の定義に現れる再帰コマンドを定義します。

この再定義はを介して行わ!れ、スタックから文字を読み取り、に遭遇するまでスタックから文字列を読み取ります;。文字は、その文字列で表されるプログラムを意味するように再定義されます。

つまり、空のプログラムとして! 自分自身を再定義することで、Ementalのループ機能を無効にできます。他のすべてのEmmentalコードは依然として完全に正常に動作し、プログラミング言語の基準の多くは依然として満たされていますが、それ以上のシンボルを再定義することは不可能です。この機能がなければ（したがって、ループできずに）、Ementalは数値が素数かどうかをテストできなくなります。

PHP

メモリ制限を1に設定すると、PHPを完全に強制終了できます。

それは完全に死にます。

これを試して：

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

    //code here

十分なメモリがないため、これはエラーをスローすることすらありません。

ディレクティブについての詳細を読むことができますmemory_limit

前のものが無効な場合、出力バッファーを使用できます。

<?php
    ob_start();

    //code here

    ob_clear();

これにより、出力が完全に削除されます。出力バッファはまだ開いているので、コードが表示されなかった後、他のいくつかのものが誤って残されます。

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

これにより、圧縮される出力をキャッチするために使用される、自動的に開始された出力バッファーを削除する問題を回避できます。

これにより、出力バッファーが削除またはフラッシュされる（ブラウザーに送信される）ことも防止されます。それを強化するために、常に空の文字列を返す出力ハンドラーが追加されます。
実行しob_end_flush(); echo "Hello, world!";ても何も生成されませんが、出力をplainで送信しますob_start();。

この問題を公開してくれた@LucasTrzesniewskiに感謝します！

リアルモードのx86マシンコード（=>ほとんどすべてのDOSプログラム）

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

すなわち

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

割り込みテーブルにあまり執着していなかったことを願っています。

Java

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

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

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

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

        // program here
    }
}

編集：カウンター対策はこの巨大な:(

stdinとstdoutをnullストリームにリダイレクトし、argsを空の配列に置き換えます。また、大量のリフレクションハックを使用して、標準IOが本当に隠されていることを確認します。最後に、セキュリティマネージャを設定して、標準IOを再作成できないようにし、プログラムが終了コードを設定できないようにします。

ルア

_ENV=""

Luaでは、_ENVすべてのグローバル変数、関数、テーブルなどが格納されている環境です。空の文字列のみに定義すると、新しいものを定義できず、すべての関数と変数が消去されます。これは、何も出力したり、入力を取り入れたり、ほとんど何もできないことを意味します。

シェークスピアプログラミング言語

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]

SPLでは、プログラムとともにダウンロードされる組み込みのパーサーは、スクリプトで何が発生する可能性があるかについて、非常に具体的なルールに従います。そのようなルールの1つは、2人のキャラクターだけが一度にステージに立つことができるということです。また、ステージ上にいなかったキャラクターをステージから退出させると混乱します。同じことは、すでにステージにいるキャラクターをステージに追加する場合にも当てはまります。パーサーはエラーを受け取ると、それ以外のことを拒否します。文字通り、プログラムとパーサーを完全にシャットダウンしてから、すべてを再度起動する必要があります。

PSこの言語がどのように機能するかわからない場合は、Googleを使用してください。それは素晴らしいです。

Smalltalk

これが適切かどうかわかりません：

Smalltalk := Nil.

これにより、ランタイム環境全体が削除され、オブジェクトエンジンがハングします。これを修正する唯一の方法は、プロセスを強制的に終了し、バックアップから再起動することです。

知らない人にとって、[Visual Works] Smalltalkの動作は少し奇妙です。ミニOSのようなものです。Smalltalkを起動すると、「メモリイメージ」がRAMにロードされ、中断したところから実行が継続されます。Smalltalk IDE全体はSmalltalkで記述されており、動的に変更可能です。

特に、Smalltalkすべてのグローバル変数を含む辞書です。特に、新しいクラスを宣言するたびに、その名前のグローバル変数が作成され、Class新しいクラスのオブジェクトをポイントします。したがってSmalltalk、Nil（基本的にnull）に設定すると、システム全体のすべてのクラスが削除されます。GUIイベントハンドラーでさえ馬鹿げています。

この変数が書き込み可能である理由がわかりません。おそらく、それはグローバル変数であり、したがってそれ自体のエントリとして存在するためです。（あなたの頭はまだ痛いですか？すべてのオブジェクトにはクラスがあり、クラスはオブジェクトなので、すべてのクラスにはクラスがありますか？クラスのクラスはメタクラスと呼ばれますが、メタクラスもオブジェクトであるため、クラス...）

辞書をヌルに置き換えるのではなくクリアすることで、おそらく同様の効果を達成できます。実際、システム内のすべてのクラスを削除するためにコーディングできるものはいくつもあり、何もできません。しかし、実際のSmalltalkコンパイラもクラスなので...言語を壊すものはIDE全体をちょっと壊すので...

ハスケル

ここにはいくつかの可能性があります。

退屈なアイデア＃1：main何もしないように定義する。これで、他のどのようなコードを記述しても、実行できなくなります。（REPLから手動で実行しない限り。）

退屈なアイデア＃2：パブリックエクスポートのないモジュールを定義します。これで、他のどのコードを記述しても、実行できなくなります。

興味深いアイデア：すべてのインポートを無効にします。

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

これで、表示可能で実行可能な関数を定義できます...しかし、何もできません。Haskellのすべての標準タイプと関数は非表示になりました。（言語に本当に深く組み込まれているいくつかのことを除いて。）

特に、I / Oは一切実行できません。また、機械精度の計算を行うこともできません。（以来Int、Double等は、現在定義されていません。）

あなたはできるまだかかわらず、いくつかの実際の計算を実行しないラムダ計算の関数を記述します。モノにデータを出し入れすることはできません。ただし、Fubar上記のモジュールを呼び出し、その代わりにI / Oを実行する別のモジュールを作成することもできます（したがって、コードが実行され、処理が行われることを証明します）。

いくつかの微妙な点：

• ダミーのfoo = foo宣言は、誰かが追加のインポートを追加するのを防ぐために必要です。（インポートは宣言の後に表示できません。）

• この状況から抜け出すことを可能にする様々な非標準のHaskell言語拡張があります。ただし、ファイルの先頭にあるコンパイラプラグマを使用して、言語拡張機能を有効にする必要があります。（または、コンパイラへのコマンドラインスイッチを使用します。それを実際に防ぐことはできません！）

PostScript

はい、PostScriptはプログラミング言語です。さらに、それはすべての言語構成要素がシステム定義関数であるプログラミング言語であり、再定義することができます...

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

英語で：

• 空の1,000要素の辞書を作成し、名前を付けMagicます。
• のすべてのキーについて、空の定義（ " "）でsystemdict同じキーをに追加します。Magic{}
• Magic辞書スタックの一番上にプッシュします。

この時点から、すべてのPostScript言語コマンドは何もしないように定義されています。私の知る限り、この状態から脱出することは不可能です。

（技術的には、あなたはちょうどあなたがまだ実行することができれば。それをシャドウイングしている、古い定義を「破壊」していないendポップであろうと、Magic辞書スタック、すべてのコマンドを非シャドーイングとバックあなたの人生を与えることをオフにします。しかし、以来、endそれ自体も影になっています...今は何もしません。）

すべてのコマンドは引き続き実行されることに注意してください...ただ、今は何もしないように定義されているだけです。エラーは発生しません。何も起こらないというだけです。（まあ、最終的にスタックオーバーフローが起こると思います...）

Linux / x86（-64）で実行されるプログラム

このプログラムはCで作成されていますが、Linux / x86（-32または-64）で実行されているプログラムの実行を中断する可能性があります。中断するプログラムのコマンドライン呼び出しの前に追加します。

デバッガAPIを使用して、ターゲットプログラムが出力を生成しないようにします。具体的には、プロセス外の世界に何かを伝えることができるすべてのシステムコール（writeもちろん、もちろん、openファイルを作成するkillとき、別のプロセスに適用されると、ソケットAPIの大部分が...）は失敗します実装されていないかのように。_exit許可されますが、終了コードはゼロで上書きされます。

この回答の前の版とは異なり、多くのプログラムはこれらの条件下でほぼ完了するまで実行できます。彼らの仕事がすべて無駄になっているだけです。たとえば、./no-syscalls /bin/ls（GNU coreutilsを想定してls）実行すると、ディレクトリ全体が読み取られてフォーマットされ、write出力を生成するためのすべての呼び出しが失敗します。（ただし、すべてのX11クライアントなど、双方向通信チャネルを開く必要があるものはすべてその時点で失敗します。許可することを考えましたが、許可しsocketないことを考えましたが、send抜け穴を開く可能性が高すぎるように思われました。）

動作を調整するためのコマンドラインオプションがいくつかあります。

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

動的にリンクされたプログラムは、-eモードで動的リンカーから抜け出すことさえありません。 -S明らかにポリシーに大きな穴が開きますが、何も機能していないことをうめくプログラムを見るのは面白いかもしれません。

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

/usr/include/asm*/unistd.h別のウィンドウで開いた状態でログ出力を読み取る必要があります。これはすでに十分に長いためです。

悲しいことに、これが使用するデバッガーインターフェイスは、Unix実装間で一貫性が弱く、本質的にCPU固有です。これは、他のCPUアーキテクチャ（ただの適切な定義を追加するポートそれに比較的簡単になりますSYSCALL_*_REG）、そしてそれはおそらくだ可能性がある任意のUnixのにポートにそれをしptraceていますが、相違に対処するとして広くだけでなくシステムコールのホワイトリストとマックが必要になる場合がありますで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

これが実際に機能するかどうかはわかりませんが、理論\的にはエスケープ文字として壊れるので、修正する方法はありません。通常、TeXはファイルを読み書きできますが、現在はロジックに依存するものは何も書き込むことができません。したがって、OPで定義されているように言語が壊れています。

編集： コメントから取られた他のkillコマンド（両方とも実行する必要のある規則に違反する可能性がありますが）：

• \def\fi{}\iffalseでSMPLブランチ場合、非閉鎖可能なを作成します
• \catcode13=9%by iwillnotexist idonotexistは終わりのないコメントを作成します

スクラッチ

when [timer v] > (0)エディタにいる場合でも、コードを開始する前である、とすぐにコードが初期化されるように実行されます。これwhen I receive (join[][])により、何かがブロードキャストされるたびにエラーがスローされ、FlashのDeveloperバージョンを使用している場合、コードの実行が一時停止されます。このbreak関数はクローンを作成し、ブロードキャストエラーをトリガーします。すべてのクローンは2秒間続き、それ自体を削除してスタックに負担をかけます。そして、すべてのクローンはに応答し、サブルーチンをwhen [timer v] > (0)実行しbreak、タイマーをリセットします。これにより、タイマーコードが再度実行されます。また、各クローンはすべてのブロードキャストエラーにも応答します。つまり、評価ごとのエラーbreak数はクローンの数の2乗になります。break関数が持っていることを言及するのを忘れましたかrun without screen refreshこのチェックボックスをオンにすると、エディターがフリーズ、衝撃、遅延し、メモリを取得して割り当てます。そして、CPUを最大化します。

この実行中に任意の場所に追加されたコードは、それ自体がクローンを作成できず（300クローンの制限を超えました）、それを実行しているコンピューターを加熱してクラッシュさせます。そして、これ以上掴むことができなくなるまでメモリを掴み、変数を誤動作させます。

そして、when [timer v] > (0)ブロックをトリガーするにはラグが長すぎても、それはまだ実行されていbreakます。

@towerofnixにwhen I receive、しばらく前に見つけた不具合について思い出させてくれて、のアイデアをくれてありがとうrun without screen refresh。あなたがこれを気に入ったなら、ここにオリジナルがあります：https : //codegolf.stackexchange.com/a/61357/43394

Mathematica / Wolfram言語

Mathematicaはインタープリター言語であり、コマンド名はプログラマーが操作できる記号です。組み込み演算子を削除することはできませんが、それらをオーバーロードしたり、機能を変更したりできます。次は、内部で変数に割り当てるために必要な「With」コマンドをスクランブルします。この変更により、割り当てが完了するまでカーネルが引数を評価せずに保持することがなくなり、言語が完全に停止します。

ClearAttributes["With", HoldAll]

このコマンドがインタラクティブセッションまたはコードブロック内で実行された場合、Mathematicaは追加することさえできません1+1（結果のエラーメッセージは1ページほどなので、ここには含めません）。

PHP

私はそれが実際に動作することに驚いていますが、すべての出力を閉じSTDOUTてSTDERR抑制します。それらが再び開かれないように/dev/null、ファイル記述子0、1、2を再割り当てするために3回開きます。

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

// insert program here

それについての詳細：https : //stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

DOSバッチ（Windows 95より前）

CTTY

引数なしで発行すると、コマンドラインが端末から切断されます。さらに入力を読み取ったり、出力を生成しようとしても、何も実行されません。

CTTYを正しく使用する方法を知りたい場合：

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

少し強力なバッチファイルでモデムに応答し、CTTYにダイヤルインしたものを接続することもできます。

Common Lisp

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

これらの開き括弧が必要ないことを願っています。

これはLispリーダーにの各インスタンスを(、(lambda (x y) ())2つの引数を取り何も返さない関数の呼び出しで置き換えるように指示するリーダーマクロです。したがって、たとえば、(foo)として読み取り、変数としてfoo)解釈fooしてから、一致しない括弧エラーをスローし0ます。

スクラッチ

ブラウザ（および理論的にはコンピュータ）をクラッシュさせる非常に簡単な例を次に示します。

これを約20秒間実行した後、スクラッチで2.65 GBのメモリを失いました。ほんの一瞬で5 GBがなくなりました。

これを実行する前に、Adobe FlashまたはWebブラウザーを強制終了する手段があることを強くお勧めします。

^{私は本当にのようなクールな答え作りたかったclear(this)JS 1を残念ながらスクラッチはそれを行うための任意の方法を持っていません。Scratchを使用できないようにする別の方法を見つけた場合は、この投稿を自由に更新（または独自に作成）してください！}

火

::=

最後に改行がある

thue言語はルールセットの定義に依存し、a ::=はルールセットの終わりを示します。行うことは不可能である何でもそれを行うルールを定義せずにthueでは、それほど関係なく、あなたが後に入れたものを::=、何も起こりませんすることができます。

別の答え

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

（など、Unicodeのすべての文字について、そのA文字の前の文字と印刷不可能な文字を含む）。これにはコマンドラインオプションが必要-rです。

MATLAB

次のコードは、環境を完全に使用不可にします¹。

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

これにより、builtin関数と、これらの関数を呼び出そうとするたびにclear単純に返さfalseれる新しい匿名関数ハンドルを持つ関数がオーバーライドされます。builtin機能は確実にビルトインされているMATLABに（物事のようなものと同じ名前ですあなたはMATLABで書く任意のカスタム関数がある場合はsum、max、min、あなたがオーバーロードされた関数の代わりに明確にこれらを呼び出すことができます、など） 。同様に、clear現在宣言されているすべての変数をクリアして、新たに開始できるようにします。これらの機能を削除すると、プログラムを再起動しない限り、MATLABを使用できなくなります。

MATLAB R2015aでは、次のメッセージも表示されます。

ワークスペースは、後で使用できるように、現在環境で宣言されている変数です。これにより、ワークスペースが永久に無効になるため、作成しようとする変数は保存されず、MATLABでコード行を実行する際に進行できません。

^{1：当初アイデアを発見したユーザーDev-iLにクレジットが付与されます。}

///

/\///

///の唯一の操作は、次のような繰り返しの文字列置換です/pattern/replacement/。

このコードはeveryを削除する/ため、繰り返し文字列置換を使用することはできません。したがって、基本的にその後に記述するすべてが印刷されます（/s を除く）。

まだ\sを使用できますが、それはあまり役に立ちません。

Befunge-96

'~h

ユーザーのコードは、これらがソースの最初の3文字である限り、このシーケンスの後であればどこでも使用できます。

'コマンド（ワンショット文字列モード）のASCII値をプッシュし~、スタック（すなわち126）上に、およびhコマンドは、として知られているものを設定しますホリスティックデルタその値を持ちます。Befunge-96に慣れていない人にとって、ホリスティックデルタは、インタープリターが遭遇するすべてのコマンドバイトの値に追加されるオフセットです。

デルタが126に設定されると、生成可能な有効なコマンド~は、ソース内のヌルバイトを介した（文字入力）のみです。nullバイト以外のものは126より大きい値に変換され、これらの値はどれも有効なBefungeコマンドではありません。

これにより、プログラミング言語としての資格を得る資格がなくなると言っても安全だと思います。

ブー

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

そして、プロジェクトのどこかで、

harmless

無害な名前のシンプルなマクロですが、驚くほどイライラさせる効果があります。Booコンパイラは、ソースを解析してASTに開始し、コード生成で終了するマルチステップパイプラインを使用します。（通常、さまざまなアプリケーション用に再構成できます。）間のすべてのステップは、ASTでさまざまな操作を実行します。

途中にはマクロ展開段階があり、マクロはコンパイラのコンテキストで実行されます。再構成可能なパイプラインについて、最後の段落のビットを覚えていますか？マクロ展開中にパイプラインをクリアするマクロを呼び出した場合、ユーザーにはエラーは表示されませんが、マクロ展開後のすべての手順（コード生成を含む）は表示されなくなります。したがって、コンパイルは成功したように見えますが、エラーメッセージは表示されませんが、何らかの理由でバイナリは生成されません！マクロと呼び出しをうまく隠せば、最高のトラブルシューターでさえ確実に駆け抜けることができます。

NGN / APL

NGN / APLはプリミティブの再定義を許可するので、←すべてのプリミティブ関数を⊢（「パススルー」：両方⊢3と2⊢3を与える3）に再定義（）すると、言語はまったく役に立たなくなります。

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

ここで試してみてください。

ルビー（29文字）

class Object;def send;end;end

「送信」は、Ruby内でメソッドが呼び出されるたびに内部で使用され、すべてのオブジェクトがObjectクラスから継承されるためです。これにより、実行中のメソッドが停止します。

おもしろい事実：これは理論的には完全に健全です。しかし、何らかの理由で、Ruby言語を妨害しないように見えます。なぜこのコードを実行し、それでもオープンなRuby環境を使用できるのか、私にはわかりません。

Tcl

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

これによりif、とを除くすべてのキーワードが言語から削除されますrename。

上記のコードにより、新しいコードがエラーになります。したがって、新しく挿入されたコードが実際に「実行」されるかどうかは議論の余地があります。以下は、新しいコードを実行しますが、すべてのキーワード（ifおよびを除くproc）を無操作に変更するため、何もしません：

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

キーワードを削除する代わりに、このコードは何もしない関数に置き換えます。

（注：Tclにはキーワードがなく、機能のみがあるため、ここでは「キーワード」を非常に緩やかに使用しています）

フーン

=<  ~
(your code)

フーンは奇妙です。他のプログラミング言語とはまったく異なり、構文だけでなくセマンティクスも異なります。ただし、Hexagonyのような言語とは異なり、意図的に難解になることはありませんでした。

Hoon は、最小限のコンビネータベースのVMであるNockにコンパイルします。Nockは愚かです。仕様は340バイトにgzip圧縮できます。唯一の数学演算はインクリメントです。すべては名詞です。アトム（bignum）またはセル（名詞のペア）であり、メモリモデル全体が不変の非循環バイナリツリーに配置されています。唯一の出力は、式が縮小する名詞です。

奇妙なコンパイルターゲットのため、Hoonも奇妙です。それは完全に純粋です。Hoonは、「コンテキスト」で評価されるNock式にコンパイルします。カーネル全体とstdlibは、すべての変数とともに、コンテキストによってプログラムに暗黙的に渡されます。

Hoonを使用不可にする=<には、「bのコンテキストでaを評価する」だけを使用します。私たちは常に~ゼロを評価しています。何をbしても、それが減少する値を変更することはできません。また、副作用を持たないため、入力または出力を行うことはできません。

サイドノート：Hoon（純粋！）からの入力を実際に促すことはできないので、ルールにより、実際にはプログラミング言語ではありません。入力は関数の引数を介して行われ、出力は戻り値を介して行われます（または~&、これはよりprintfデバッグ機能であり、プログラムに対して透過的です）。

プログラムがUrbitで入力を取得するには、入力を受け付ける関数を返すプログラムを実際に作成します。シェルがユーザーに代わって要求し、コールバックに渡します。

タクシー、2354バイト。

この小さなプログラムは、タウンズバーグを介してガソリンを使い果たして、タクシーを大規模に走らせます。この後に実行するコードはすぐにエラーになりerror: out of gasます。そして、たとえガソリンスタンドに着くことができたとしても、それは可能だとは思わないが、乗客がいないのでお金が集まらないので、ガソリンを得ることができなかった。

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

まあ、少なくともIE11では。

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

ドキュメントへの書き込み、グローバル変数への書き込み、関数からの戻りを無効にします。

出力方法を逃した場合はコメントしてください！

Python 2、めちゃくちゃ大きい

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

このめちゃくちゃ大量のコードはrexec、「ok」リストに追加された多数の新しいモジュールと修正された多数の弱点（object.__subclasses__()少なくとも2つの他のpythonを作成したメソッドを含む）無効な回答）。

このコードのかなりの部分（クラスおよびクラス全体の__init__メソッド）は、Pythonの標準ライブラリから少し変更してコピーされます。RExecModuleImporter