Спробуйте написати якийсь код своєю мовою та зробіть так, щоб він більше не відповідав нашим критеріям бути мовою програмування .

Мова відповідає нашим критеріям (спрощена версія для цього завдання) бути мовою програмування, якщо:

• Він може певним чином читати дані користувача, що представляють кортежі додатних цілих чисел.
• Він може виводити щонайменше два різні можливі результати залежно від введених даних.
• Це може взяти два натуральних числа і додати їх (і результат може вплинути на результат).
• Він може приймати додатне ціле число і вирішити, чи є простим (і результат може вплинути на результат).
• Для цього виклику ігнорується будь-який вид виводу, який не є дозволеним методом виводу для звичайного виклику . Тож не має значення, чи програма також може відтворювати музику або публікувати повідомлення через HTTP тощо.
• Оновлення: Ви також можете вибрати один або кілька дозволених методів виводу та проігнорувати всі інші. Але ви повинні використовувати одне і те ж визначення скрізь у наступних критеріях. І якщо ваша програма може вимкнути більше одного способу виведення - це вартує більше коштів.

Такі приклади, як неможливість виведення або відключення всіх конструкцій циклу, тому він не зможе зробити перевірку первинності і переконатися, що користувач не зможе їх повторно включити.

Вам слід залишити місце для вставки нового коду. За замовчуванням він знаходиться в кінці вашого коду. Якщо ми розглядаємо, як у своїй відповіді поставити вихідний код у цьому місці та запустити повний код як повну програму інтерпретатора нової мови, ця мова не повинна відповідати критеріям.

Але вставлений код повинен бути виконаний таким чином, як мова, що відповідає критеріям:

• Вставлений код повинен бути граматично таким же, як і щось (скажімо, це блок коду в наступних критеріях), які зазвичай відповідають критеріям, з точки зору того, хто хоче написати виділення синтаксису. Тому воно не може бути в рядку, коментарі тощо.
• Вставний код повинен бути фактично виконаний таким чином, щоб він відповідав критеріям. Отже, це не може бути у невикористаній функції або sizeofв C, ви не можете просто виконати лише нефункціональну частину коду, і ви не можете поставити її після нескінченного циклу тощо.
• Ви не можете обмежити кількість можливих граматично правильних програм, створених таким чином. Якщо в мові, якою ви користуєтесь, вже є щось на зразок обмеження довжини, воно не повинно відповідати критеріям, навіть якщо ця межа буде знята.
• Ви не можете змінювати або "використовувати" вміст вводу / виводу, але ви можете запобігти їх доступу.
• Ці критерії зазвичай застосовуються лише до мов без явного вводу / виводу:
  • Ваш код повинен перенаправляти вхід користувача (який містить інформацію довільної довжини) на вставлений код, якщо блок коду зазвичай не в змозі отримати введення користувача безпосередньо / явно на мові, яку ви використовуєте.
  • Ваш код повинен надрукувати повернене значення вставленого коду, якщо блок коду зазвичай не в змозі виводити речі безпосередньо / явно на мові, яку ви використовуєте.
  • У випадку, якщо ви друкуєте повернене значення, і воно вводиться мовою, якою ви користуєтесь, повернутий тип повинен мати можливість мати два різних практично можливих значення. Наприклад, ви не можете використовувати тип 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 не потрібно. Використовується двигун SpiderMonkey (оболонка не браузер), оригінальний двигун JS.}

Ементаль

;#33!

Я знаю, це не код гольфу, але правильний інструмент для роботи, ви знаєте ...

Код користувача можна вставити після !.

Емменталь - це цікавий езоланг, заснований на переписуванні перекладача. Кожен окремий символ (включаючи вбудовані символи) може бути перероблений як довільна програма Емменталь. Мова настільки покладається на цю особливість, що не забезпечує ніяких циклічних конструкцій. Натомість ви визначаєте рекурсивні команди, які відображаються у власних визначеннях.

Це перевизначення відбувається через !, який зчитує персонаж із стека, а потім зчитує рядок із стека, поки не зустріне a ;. Потім символ переосмислюється, щоб означати програму, представлену цим рядком.

Це означає, що ми можемо відключити циклічні функції Emmental, переосмисливши ! себе як порожню програму. Незважаючи на те, що всі інші коди Emmental все ще працюють ідеально, і багато критеріїв мови програмування все ще виконані, неможливо перезначити більше ніяких символів. Без цієї функції (а отже, не маючи змоги зробити цикл), Емменталь більше не може перевірити, чи є число простим.

PHP

Можна повністю вбити PHP, встановивши межу пам'яті в 1.

Він повністю помре.

Спробуйте це:

<?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!";нічого не дасть, але буде надсилати вихід простою 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 на нульові потоки та замінює аргументи порожнім масивом. Також використовується величезна кількість хак-відбитків, щоб переконатися, що стандартний IO справді прихований. Нарешті, він встановлює диспетчер безпеки, щоб переконатися, що стандартний IO не може бути відтворений, і що програма не може встановити вихідний код.

Луа

_ENV=""

У Луа _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 вбудований парсер, який завантажується разом із програмою, дотримується дуже специфічних правил щодо того, що може статися у сценарії. Одне з таких правил - одразу на сцені можуть бути лише два персонажі. Також змушення персонажа вийти на сцену, який ніколи не був на сцені, збентежить це. Те саме стосується додавання персонажа до сцени, яка вже на сцені. Коли аналізатор отримає помилку, він відмовиться робити щось інше; ви буквально повинні повністю вимкнути програму та аналізатор, а потім запустити все заново.

PS Якщо ви не маєте уявлення про те, як працює ця мова, Google. Це приголомшливо.

Невеличка розмова

Я не впевнений, чи відповідає це:

Smalltalk := Nil.

Це видаляє все середовище виконання часу, підвішуючи двигун об'єкта. Єдиний спосіб виправити це - примусово припинити процес і перезапустити з резервного копіювання.

Для тих, хто не знає, спосіб [Visual Works] Smalltalk працює трохи дивно. Це як міні-ОС. Коли ви запускаєте Smalltalk, ви завантажуєте "образ пам'яті" в оперативну пам'ять, і він продовжує виконувати з того місця, де він зупинився. Весь IDAL Smalltalk написаний у Smalltalk і динамічно змінюється.

Зокрема, Smalltalkце словник, що містить усі глобальні змінні. Зокрема, кожного разу, коли ви оголошуєте новий клас, створюється глобальна змінна з цим ім'ям, що вказує на Classоб'єкт для вашого нового класу. Таким чином, налаштування Smalltalkна Nil(в основному недійсне) видаляє всі класи у всій системі. Навіть обробники подій GUI стають пустими.

Я поняття не маю, чому цю змінну навіть можна записати. Можливо, тому, що це глобальна змінна, і тому існує як запис всередині себе. (У вас ще болить голова? Чи згадував я, що кожен об'єкт має клас, а класи - це об'єкти, тому кожен клас має клас? Клас класу називається метакласом, але метаклас - це також об'єкт, який, таким чином, має клас...)

Можливо, ви могли б досягти подібного ефекту, очистивши словник, а не замінивши його на null. Дійсно, існує будь-яка кількість речей, які ви могли б кодувати, щоб видалити всі класи в системі, не даючи змоги нічого зробити. Але оскільки фактичний компілятор Smalltalk - це також клас ... все, що порушує мову, також начебто порушує всю IDE, так що ...

Хаскелл

Тут є пара можливостей.

Нудна ідея №1: Визначте mainнічого не робити. Тепер незалежно від того, який інший код ви пишете, він ніколи не може виконати. (Якщо ви вручну не запустите її з REPL.)

Нудна ідея №2: Визначте модуль без публічного експорту. Тепер незалежно від того, який інший код ви пишете, він ніколи не може виконати.

Цікава ідея: вимкнути весь імпорт.

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

Тепер ви можете визначити функції , які є видимими і можуть бути запущені ... але вони нічого не можуть зробити. Усі стандартні типи та функції Haskell тепер приховані. (За винятком кількох речей, дійсно глибоко вкладених у мову.)

Зокрема, ви не можете виконувати будь-які введення-виведення. Ви також не можете робити арифметику з точністю до машини. (Оскільки Int, Doubleтощо, зараз не визначено.)

Ви все ще можете записати функції лямбда-числення, які виконують деякі реальні обчислення. Ви просто не можете отримувати будь-які дані з речі. Але ви, звичайно, можете написати інший, окремий модуль, який викликає Fubarмодуль вище і робить введення / вивід від свого імені (таким чином, доказуючи, що код виконує і виконує завдання).

Деякі тонкощі:

• Фіктивна foo = fooдекларація потрібна для того, щоб хтось не додав додатковий імпорт. (Імпорт не може з’являтися після декларацій.)

• Існують різні нестандартні розширення мови Haskell, які дозволять вам вийти з цієї ситуації. Але розширення мови потрібно ввімкнути прагмою компілятора вгорі файлу. (Або з перемиканням командного рядка на компілятор. Я не можу реально запобігти цьому!)

PostScript

Так, PostScript - мова програмування. Більше того, це мова програмування, де всі мовні конструкції є визначеними системою функціями, які можна переробити ...

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

Англійською:

• Створіть порожній словник з 1000 елементами та назвіть його Magic.
• Для кожної клавіші systemdictдодайте ту саму клавішу Magicіз порожнім визначенням (" {}").
• Натисніть Magicна верхню частину словника.

З цього моменту кожна команда мови PostScript визначається, щоб нічого не робити. AFAIK, неможливо уникнути цієї умови.

(Технічно ви не «знищуєте» старі визначення, ви просто їх затінюєте. Якщо ви все-таки можете виконати end, це вискочить Magicстек словника, не відтіняючи всі команди і повертаючи ваше життя назад. Але оскільки endсама теж затінена ... вона нічого не зробить зараз.)

Зауважте, що всі команди все ще будуть виконуватись ... це просто те, що тепер вони визначені, щоб нічого не робити. Ви не отримаєте жодної помилки, просто нічого не станеться. (Ну, мабуть, переповнення стека відбудеться зрештою ...)

Будь-яка програма, що виконується під Linux / x86 (-64)

Ця програма написана на C, але вона може порушити виконання будь-якої програми, що працює під Linux / x86 (-32 або -64). Ви додаєте його до виклику командного рядка програми, яку ви хочете зірвати.

Він використовує API налагодження, щоб запобігти цільовій програмі виробляти будь-які результати. Зокрема, всі системні виклики, які можуть щось повідомляти світу поза процесом (найочевидно write, звичайно, але також openпри створенні файлу, основна частина API сокета, killзастосована до іншого процесу, ...) вийде з ладу ніби вони були нереалізовані. _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, і по суті є процесорними. Було б досить просто перенести його на інші архітектури процесора (просто додайте відповідні визначення SYSCALL_*_REG), і, ймовірно, можливо перенести його на будь-який Unix, який є ptrace, але, можливо, вам доведеться широко зв’язатися з білим списком syscall, а також мати справу з розбіжностями в 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 може читати та записувати файли, тепер він не може записати нічого, що залежить від логіки. Таким чином, мова тепер порушена, як визначено ОП.

EDIT: Інші команди вбивства, взяті з коментарів (хоча обидва можуть порушити правило коду, яке необхідно виконати):

• \def\fi{}\iffalseза допомогою smpl створює незамкнений, якщо гілка
• \catcode13=9%автор iwillnotexist idonotexist створює нескінченний коментар

Скретч

when [timer v] > (0)Працюватиме , як тільки код ініціалізації, який , якщо ви перебуваєте в редакторі , перш ніж навіть почати код. when I receive (join[][])Приведе до помилки бути викинутий кожен раз , коли що - або транслюється, затримавшись виконання коду , якщо у вас є версії розробник Flash. breakФункція буде створювати клони, і викликати помилку мовлення. Кожен клон триватиме дві секунди, після чого видаляється, ставлячи напругу на стек. І кожен клон реагує на when [timer v] > (0)запуск breakпідпрограми та скидання таймера, що призводить до повторного запуску коду таймера. Крім того, кожен клон також відповість на кожну помилку мовлення, тобто кількість помилок на оцінку break- це кількість клонів у квадраті. Я забув згадати, що breakфункція маєrun without screen refreshперевірено, змусивши редактор замерзнути, тріскатися та відставати, а також захоплювати та розподіляти пам'ять. І максимізація процесора.

Будь-який код, доданий будь-де з цим запуском, виявиться не в змозі створити клонів (перевищено 300 клонних меж), а також нагріти та вибити з ладу комп'ютер, на якому працює. І захоплюючи пам’ять, поки не буде більше захоплення, залишаючи змінні недоброзичливими.

І після того, як буде занадто багато затримок для запуску when [timer v] > (0)блоку, він все одно буде працювати break.

Завдяки @towerofnix за те, що він нагадував мені про when I receiveглюки, які я знайшов деякий час назад, і дав мені ідею run without screen refresh. Якщо вам сподобалось це, ось оригінал: https://codegolf.stackexchange.com/a/61357/43394

Математика / Вольфрам Мова

Mathematica - це інтерпретована мова, в якій імена команд - це символи, якими може керувати програміст. Ви не можете видалити вбудовані оператори, але ви можете їх перевантажувати чи іншим чином змінювати їх функції. Нижче переглядається команда "С", яка потрібна для присвоєння змінним навіть внутрішньо. Ця зміна заважає ядру тримати аргументи неоціненими, поки призначення не буде завершено, і це вбиває мову досить мертвою.

ClearAttributes["With", HoldAll]

Якщо ця команда виконується в інтерактивному сеансі або в блоці коду, Mathematica навіть не зможе додати 1+1(отримане повідомлення про помилку триває приблизно сторінку, тому я сюди не включатиму її).

PHP

Я здивований, що це насправді працює, але закриття STDOUTта STDERRпридушення всіх результатів. Щоб переконатися, що вони не відкриються знову, ми відкриваємо /dev/nullтри рази для переназначення дескрипторів файлів 0, 1 і 2:

<?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.

Звичайний Лисп

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

Сподіваюсь, вам не знадобилися ці відкривальні дужки.

Це макрос читача, який повідомляє Reader Readp замінити кожен екземпляр (викликом до (lambda (x y) ())функції, яка бере два аргументи і нічого не повертає. Так, наприклад, він буде читати (foo)як foo), інтерпретувати fooяк змінну, а потім кидати на незрівнянну помилку дужок 0.

Скретч

Ось досить простий приклад, який збиває ваш браузер (і, теоретично, ваш комп'ютер):

Я залишив цю функцію близько двадцяти секунд, а потім втратив 2,65 ГБ пам’яті Scratch. Тільки через мить і 5 ГБ пішло.

Я настійно пропоную у вас є засоби змусити вийти з Adobe Flash або веб-браузера, перш ніж запускати це!

^{Я дуже хотів зробити класну відповідь, як clear(this)JS, але, на жаль, Scratch не має жодних способів це зробити. Не соромтеся оновлювати цю публікацію (або зробити свою власну), якщо ви дійсно знайдете інший спосіб зробити Scratch непридатним!}

Чт

::=

З новим рядком в кінці

Мова туї покладається на визначення наборів правил, а ::=позначає кінець набору правил. Це неможливо зробити НІЧОГО в 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/.

Цей код видаляє кожен /, тому ви не можете використовувати повторну заміну рядків, тому в основному все, що ви напишете після цього, буде надруковано (за винятком /s).

Ви все ще можете використовувати \s, але це не дуже допоможе вам.

Befunge-96

'~h

Код користувача може слідувати будь-де після цієї послідовності, якщо це перші три символи в джерелі.

'Команда (режим струна один постріл) виштовхує значення ASCII з ~стек (тобто 126), і hкоманда потім встановлює , що відомо як холістичної Delta з цим значенням. Для тих, хто не знайомий з Befunge-96, цілісна дельта - це зміщення, яке додається до значення кожного байта команди, з яким стикається інтерпретатор.

Після встановлення дельти на 126, єдиною дійсною командою, яка може бути сформована, є ~(введення символів) через нульовий байт у джерелі. Все, окрім нульового байта, переведене на значення більше 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

Оскільки "send" використовується всередині кожного разу, коли метод викликається в Ruby, і оскільки всі об'єкти успадковуються від класу Object. Це повинно зупинити запуск будь-якого методу.

Факт забави: теоретично це ідеально. Але, здається, чомусь не лунати мовою Рубі. Я поняття не маю, чому можна запустити цей код, а потім все-таки використовувати відкрите середовище 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)

Хун - це дивно. Це майже повністю на відміну від інших мов програмування не тільки в синтаксисі, але і в семантиці. На відміну від таких мов, як гексагонія, це не було навмисно езотеричним.

Hoon компілюється до Нока , мінімального комбінатора на базі VM. Нок дурний: специфікацію можна отримати на 340 байт. Єдина математична операція - приріст. Все - це іменник: атом (bignum) або клітина (пара іменників), уся модель пам’яті розташована у незмінному ациклічному бінарному дереві. Єдиний вихід - іменник, до якого вираз зводиться.

Через дивну мету компіляції Хун також дивна: вона абсолютно чиста. Hoon складається до виразу Нока, який оцінюється на "контексті". Все ядро ​​та stdlib, разом із усіма змінними, контекстом передаються неявно програмі.

Для того, щоб зробити Hoon непридатним, ми просто використовуємо =<, що є "оцінка a в контексті b". Ми завжди оцінюємо ~, що дорівнює нулю. Незважаючи на те, що 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) {}
    })({})
);

Вимикає запис у документ, запис у глобальну змінну та повернення з функції.

Прокоментуйте, якщо я пропустив метод виведення!

Пітон 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модуля (занедбаного в python 2.3), з купою нових модулів, доданих до списку "ok", та виправленою купою слабких сторін (включаючи object.__subclasses__()метод, який створив принаймні два інших python відповіді недійсні).

Досить трохи цього коду ( __init__метод RExecкласу та всього ModuleImporterкласу) скопіюється із стандартної бібліотеки python з невеликими модифікаціями.