Сделайте свой язык непригодным для использования

191

Попробуйте написать какой-нибудь код на вашем языке и сделать так, чтобы он больше не отвечал нашим критериям быть языком программирования .

Язык удовлетворяет нашим критериям (упрощенная версия для этой задачи) быть языком программирования, если:

  • Он может читать пользовательский ввод, представляющий наборы натуральных чисел в некотором роде.
  • Он может выводить как минимум два разных возможных результата в зависимости от ввода.
  • Он может взять два положительных целых числа и добавить их (и результат может повлиять на вывод).
  • Он может взять положительное целое число и решить, является ли оно простым (и результат может повлиять на результат).
  • Для этой задачи любой вид вывода, который не является допустимым методом вывода для обычного вызова , игнорируется. Таким образом, не имеет значения, может ли программа воспроизводить музыкальные произведения или отправлять сообщения через HTTP и т. Д.
  • Обновление: вы также можете выбрать один или несколько разрешенных методов вывода и игнорировать все остальные. Но вы должны использовать одно и то же определение везде в следующих критериях. И если ваша программа может отключить более одного метода вывода - это стоит больше голосов.

Примеры, такие как отключение вывода или отключение всех конструкций цикла, чтобы он не смог выполнить тест на простоту, и проверка того, что пользователь не сможет их повторно включить.

Вы должны оставить место для вставки нового кода. По умолчанию это в конце вашего кода. Если мы рассмотрим возможность добавления исходного кода в это место в вашем ответе и запуска полного кода в качестве полной программы, переводчика нового языка, этот язык не должен удовлетворять критериям.

Но вставленный код должен быть выполнен таким образом, как язык, удовлетворяющий критериям:

  • Вставленный код должен быть грамматически таким же, как что-то (скажем, это кодовый блок в следующих критериях), который обычно удовлетворяет критериям с точки зрения того, кто хочет написать подсветку синтаксиса. Так что это не может быть в строке, комментарии и т. Д.
  • Вставленный код должен быть фактически выполнен таким образом, чтобы он удовлетворял критериям. Таким образом, это не может быть в неиспользуемой функции или sizeofв C, вы не можете просто выполнить только нефункциональную часть в коде, и вы не можете поместить ее после бесконечного цикла и т. Д.
  • Вы не можете ограничить количество возможных грамматически правильных программ, сгенерированных таким образом. Если в используемом языке уже есть что-то вроде ограничения длины, оно не должно удовлетворять критериям, даже если это ограничение будет снято.
  • Вы не можете изменять или «использовать» содержимое ввода / вывода, но вы можете предотвратить доступ к ним.
  • Эти критерии обычно применяются только к языкам без явного ввода-вывода:
    • Ваш код должен перенаправить пользовательский ввод (который содержит информацию произвольной длины) на вставленный код, если блок кода обычно не может получить пользовательский ввод прямо / явно на языке, который вы используете.
    • Ваш код должен напечатать возвращенное значение вставленного кода, если блок кода обычно не может выводить вещи прямо / явно на языке, который вы используете.
    • Если вы печатаете возвращаемое значение, и оно набрано на языке, который вы используете, возвращаемый тип должен иметь 2 разных практически возможных значения. Например, вы не можете использовать тип struct {}или struct {private:int x;}в C ++.

Это популярность-конкурс. Наибольшее количество голосов правильного ответа (так что никто не заметил ошибку или все ошибки исправляются) выигрывает.

Разъяснения

  • Вы не должны изменять код в текстовой форме, но можете изменить синтаксис, прежде чем код будет интерпретирован или скомпилирован.
  • Вы можете делать другие вещи во время работы кода. Но причина, по которой он не удовлетворяет критериям, должна быть в самом вставленном коде. Это может привести к ошибке из-за вмешательства другого потока, но не может быть просто уничтожено другим потоком.
  • Все спецификации в основном означают, что оно должно быть грамматически вероятно удовлетворяющим критериям, если все встроенные модули не были изменены, но на самом деле не изменились . Это хорошо, если вы найдете какие-либо грамматические обходные пути, например, правильно передали параметры в блок кода, но не можете их использовать каким-либо образом.
  • Опять же, вставленный код должен быть действительно выполнен. Код после бесконечного цикла или сбоя считается «фактически не выполненным», поэтому недействительным . Эти ответы могут быть интересными, но на этом сайте уже есть некоторые другие вопросы с бесконечным циклом или сбои, и вы можете найти более подходящий для ответа. Если нет, подумайте над тем, чтобы задать новый вопрос. Примеры этих вопросов:

Leaderboard

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>

jimmy23013
источник
Могу ли я изменить код перед его выполнением? Кроме того, могу ли я запустить другой код, пока я выполняю данный код?
Голубой
21
Я думаю, это могло бы стать действительно большой проблемой для полицейских и грабителей.
DankMemes
6
@DankMemes Согласен. В настоящее время это слишком расплывчато, и большинство ответов будет признано недействительным, если найти обходной путь. CnR с этой предпосылкой был бы восхитителен.
Mego
3
Поэтому кажется, что в языках с явным вводом-выводом допустимо делать совершенно скучные вещи, такие как чтение и отбрасывание содержимого стандартного ввода. Он устанавливает совершенно несправедливое игровое поле, где некоторые языки требуют от вас аккуратного обращения с вводом-выводом для вставленного кода, а другие языки позволяют уничтожить его и запретить ввод-вывод для вставленного кода.
Питер Тейлор
1
Разрешено ли нам использовать язык, который уже непригоден для начала? (Например, JavaScript)
12Me21

Ответы:

319

JavaScript Shell

Это сделает язык совершенно непригодным для использования.

clear(this);

Разве не хорошо, что в JavaScript есть такая замечательная функция, чтобы уничтожать себя?


Это довольно просто, clearфункция полностью очищает объект. thisотносится к глобальному объекту, очищающему все, включая конструкторы и функции.


Поскольку это все очищает, все что угодно , даже определение литерала вызовет ошибку, что сделает язык совершенно бесполезным: * среда REPL не требуется. Использует движок SpiderMonkey (оболочка, а не браузер), оригинальный движок JS.Пример использования

Downgoat
источник
4
Эта clearфункция, кажется, является специфическим для оболочки SpiderMonkey дополнением, а не универсальной JavaScript-функцией. Это, конечно, не появляется в спецификации ES5 § Свойства функции глобального объекта . Я попытался это с nodeи получил «ReferenceError: clear не определен». В консоли Chrome и Firefox clearфункция просто очищает консоль, независимо от того, какие аргументы ей переданы. Или, возможно, инструмент, который вы использовали, соответствовал версии ECMAScript старше 5.1?
Анко
2
Не могли бы вы вместо этого изменить выражение «Разве не хорошо, что в JavaScript есть такая замечательная функция для самоуничтожения»? У JavaScript нет этой функции, только у реализации SpiderMonkey.
Анко
1
@Anko SpiderMonkey - это JavaScript, хотя он поставляется в комплекте с Firefox (SpiderMonkey - это JS-движок Firefox). Я напишу версию для node.js и т. Д. Позже, когда у меня будет время
Downgoat
6
Я думаю, что вы путаете JavaScript (язык) со SpiderMonkey (одной из многих реализаций языка ). Чрезвычайная аллегория: хотя я мог бы написать сумасшедшую реализацию C, в которой все вызовы неопределенного поведения приводят к печати полного текста Декларации прав человека, я, вероятно, не смогу утверждать, что мое представление C о "гольфе UDHR msgstr "который просто разыменовывает нулевой указатель, является допустимым C-решением. :)
Анко
8
@Anko По правилам сайта язык определяется его реализацией. Если ответ работает последовательно хотя бы в одной реализации, опубликованной перед вопросом , тогда он приемлем. Смотрите здесь и здесь . (Таким образом, код действителен. Но я не буду комментировать эту конкретную формулировку.)
jimmy23013
169

Эмменталь

;#33!

Я знаю, что это не код гольф, но подходящий инструмент для работы, вы знаете ...

Код пользователя можно вставить после !.

Emmental - интересный esolang, основанный на переписывании переводчика. Каждый отдельный символ (включая встроенные) может быть переопределен как произвольная программа Emmental. Язык настолько полагается на эту функцию, что не предоставляет циклических конструкций. Вместо этого вы определяете рекурсивные команды, которые появляются в их собственных определениях.

Это переопределение происходит через !, который читает символ из стека, а затем читает строку из стека, пока не встретит a ;. Затем символ переопределяется для обозначения программы, представленной этой строкой.

Это означает, что мы можем отключить циклические функции Emmental, переопределив ! себя как пустую программу. В то время как весь другой код Emmental все еще работает отлично, и многие критерии языка программирования все еще выполняются, невозможно переопределить другие символы. Без этой функции (и, следовательно, без возможности зацикливания) Эмменталь больше не может проверять, является ли число простым числом.

Мартин Эндер
источник
49
Отключение единственной определяющей функции языка: чистый гений. Это, безусловно, правильный инструмент для работы. +1
ETHproductions
93

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 за разоблачение этой проблемы!

Исмаэль Мигель
источник
1
Поскольку у вас может быть несколько уровней буферизации вывода, второй не работает. Часто while(ob_get_level()) ob_end_flush();используется в средах для очистки всех выходных буферов, которые могли остаться случайно открытыми.
Фабиан Шменглер
@fschmengler Это вызовет проблемы с автоматически открытыми выходными буферами, обычно используемыми для сжатия вывода с помощью gzip. Что в свою очередь победит цель.
Исмаэль Мигель
Это можно обойти с помощью:ob_end_flush(); echo "Hello, world!";
Лукаса Тресневского
8
Почему я не удивлен, что PHP оказался на вершине
таблицы
47
This shouldn't even throw any error, since there isn't enough memory for that.LOL'ed в этом :)
ETHproductions
91

Машинный код 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

Я надеюсь, что вы не были слишком привязаны к вашему столу прерываний.

Matteo Italia
источник
75
Сэр, если я могу прервать вас на несколько циклов, чтобы я мог закончить ...
Световой
6
Так что, если первая инструкция моего вставленного кода cli, а затем я исправляю таблицу прерываний и продолжаю вычислять некоторые простые числа и т. Д.?
Нейт Элдредж
3
@NateEldredge: следующий шаг - заключить остальную часть кода в кольцо 3 без батута обратно в кольцо 0; Я посмотрю, удастся ли мне собрать рабочий пример (другой возможностью было бы просканировать все адресное пространство и выкинуть все NOP cli( inpи outpтолько для хорошей меры), но я не знаю, будет ли это разрешено по правилам.
Matteo Italia
2
По крайней мере, это не помешает программе писать прямо в экранный буфер (что было довольно распространенным явлением в DOS).
Джерри Гроб
1
@NateEldredge: правила не совсем ясны по этому поводу, и если вы посмотрите вокруг, большинство ответов на самом деле состоят в модификациях среды, которые генерируют ошибку времени выполнения некоторого типа в тривиальных инструкциях (JS clear(this);, ограничение памяти в PHP, рекурсия ограничение в Python, среда для песочницы в Python и многие другие), я бы не увидел в этом проблемы.
Маттео Италия
68

Ява

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 в нулевые потоки и заменяет аргументы пустым массивом. Также использует огромное количество рефлексов, чтобы убедиться, что стандартный ввод-вывод действительно скрыт. Наконец, он устанавливает диспетчер безопасности, чтобы убедиться, что стандартный ввод-вывод не может быть воссоздан, и это гарантирует, что программы не могут установить код выхода.

DankMemes
источник
6
Negative.
Mego
10
+1 Лично я не считаю обходные пути / proc реальными препятствиями, потому что я не использую Linux, и ни моя ОС Unix, ни моя ОС Windows не имеют файловой системы / proc.
Джерри Иеремия
67
Краткое описание этой задачи: 1. JavaScript, 12 символов. 2. Эмменталь, 6 символов. 3. x86, 12 байт. 4. Питон, 42 символа. 5. Java, 2264 символа ! Почему я не удивлен?
перестал поворачиваться против часовой стрелки с
34
@ceasedtoturncounterclockwis Это потому, что java более безопасен, поэтому его сложнее взломать: D
Пьер Арло
62

Lua

_ENV=""

В Lua _ENV- это среда, в которой хранятся все глобальные переменные, функции, таблицы и т. Д. Если вы зададите ее как пустую строку, значит, вы не сможете определить что-то новое, и все функции и переменные будут стерты. Это означает, что вы не можете ничего выводить, принимать данные или делать что-либо.

TreFox
источник
1
Работает ли _ENV=5? Если так, это на один символ короче.
immibis
7
@immibis Правда, но это конкурс популярности, а не конкурс длины кода. PS - Доверься тебе дома на ответе Луа.
Pharap
+1 за Луа. Разве $ _G = nil $ не делает то же самое?
Додди
@ Doddy Нет, потому что _G - это просто копия _ENV, которую вы можете использовать для поиска переменных и тому подобного - на самом деле это не среда. Вы можете, однако, сделать _G = nil, а затем установить для среды _G, и это будет иметь тот же эффект.
TreFox,
Не совсем верно. Если у вас есть резервная копия где-то в локальной переменной, вы можете восстановить ее. И вы все еще можете определять локальные переменные и даже вызывать функции, связанные со строками!
Вэл
46

Шекспировский язык программирования

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 Если вы не знаете, как работает этот язык, воспользуйтесь им. Это круто

3.14ed_Piper
источник
1
Итак, это ошибка разбора или ошибка времени выполнения?
Фабиан Шменглер
4
@fschmengler Это в основном то же самое для интерпретируемых языков.
NWP
13
Если я добавлю код после последней строки, будет ли он выполняться ?
Sp3000
@ Sp3000 Он обязательно попробует ...... будет выглядеть так, как будто ничего необычного не произошло ... до тех пор, пока парсер не выйдет из строя. :)
3.14ed_Piper
43

Болтовня

Я не уверен, имеет ли это право:

Smalltalk := Nil.

Это удаляет всю среду выполнения, вешая движок объекта. Единственный способ исправить это - принудительно завершить процесс и перезапустить из резервной копии.

Для тех, кто не знает, способ [Visual Works] Smalltalk работает немного странно. Это как мини-ОС. Когда вы запускаете Smalltalk, вы загружаете «образ памяти» в ОЗУ, и он продолжает выполняться с того места, где остановился. Вся среда разработки Smalltalk написана на языке Smalltalk и является динамически модифицируемой.

В частности, Smalltalkэто словарь, содержащий все глобальные переменные. В частности, каждый раз, когда вы объявляете новый класс, создается глобальная переменная с таким именем, указывающая на Classобъект для вашего нового класса. Таким образом , установив Smalltalkв Nil( в основном нулевой) удаляет все классы во всей системе. Даже обработчики событий GUI идут напрасно.

Я понятия не имею, почему эта переменная даже доступна для записи. Вероятно, потому что это глобальная переменная, и, следовательно, существует как запись внутри себя. (Ваша голова еще болит? Я упоминал, что у каждого объекта есть класс, и классы являются объектами, поэтому у каждого класса есть класс? Класс класса называется метаклассом, но метакласс также является объектом, который поэтому имеет класс...)

Вероятно, вы могли бы добиться аналогичного эффекта, очистив словарь, а не заменив его нулевым. В самом деле, вы можете закодировать любое количество вещей, чтобы удалить все классы в системе, и вы не сможете ничего сделать. Но поскольку фактический компилятор Smalltalk также является классом ... все, что нарушает язык, также в некоторой степени нарушает всю IDE, поэтому ...

MathematicalOrchid
источник
Он недействителен, если он зависает, но не следующая команда. Но мне любопытно: есть ли у него класс, в котором значения могут быть как классом, так и обычным объектом? И класс, который может иметь оба этих значения и этот новый класс? И класс сам по себе?
jimmy23013
Класс Smalltalk отчасти похож на прототип JavaScript. Достаточно тяжело взломав системные классы, вы даже можете превратить Smalltalk в язык множественного наследования. Кроме того, вызовы методов являются объектами, блоки кода являются объектами ... вы можете перехватывать неопределенные вызовы методов и заставлять их делать что-то ... это очень динамичный язык. Все является объектом! В том числе IDE ...
MathematicalOrchid
1
Пришлось использовать nilвместо NilPharo.
mgarciaisaia
5
Еще один true become: false, но я думаю, что это не работает в более новых версиях языка. Вы можете убить SmallTalk / V 286 таким образом.
15
«Я упоминал, что у каждого объекта есть класс, а классы являются объектами, поэтому у каждого класса есть класс? Класс класса называется метаклассом, но метакласс также является объектом, у которого, следовательно, есть класс ... ». Как Pythonista, моя голова совсем не болит. Наоборот, я думаю, что чувствую себя как дома с Smalltalk.
Blacklight Shining
40

Haskell

Здесь есть несколько возможностей.

Скучная идея № 1: Определить mainничего не делать. Теперь независимо от того, какой другой код вы пишете, он никогда не сможет выполняться. (Если вы не запускаете его вручную из REPL.)

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

Интересная идея: отключить весь импорт.

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

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

В частности, вы не можете выполнять какие-либо операции ввода-вывода. Вы также не можете делать машинную арифметику. (Так как Int, Doubleи т. Д. Теперь не определены.)

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

Некоторые тонкости:

  • Пустая foo = fooдекларация необходима, чтобы никто не мог добавить дополнительный импорт. (Импорт не может появиться после деклараций.)

  • Существуют различные нестандартные расширения языка Haskell, которые позволят вам выбраться из этой ситуации. Но языковые расширения должны быть включены с прагмой компилятора в верхней части файла. (Или с переключателем командной строки для компилятора. Я не могу предотвратить это!)

MathematicalOrchid
источник
-0.1 Используйте foobar, написание, которое вы использовали, имеет некоторые ... непреднамеренные коннотации.
wizzwizz4
@ wizzwizz4 Я почти уверен, что "foobar" - это просто "fubar", чтобы избежать цензуры. Вот почему я стараюсь избегать этого в примерах программирования.
jpmc26
3
@ jpmc26 На самом деле он имеет длинную и выдающуюся историю, проходя через группу моделей MIT Train, популяризируясь в книге по программированию, затем включается в документацию, а затем внедряется в популярную культуру. Я уверен, что это совпадение.
wizzwizz4
Обе «скучные идеи» неверны, потому что пользовательский код на самом деле не выполняется. («Интересная идея», похоже, верна)
pppery
40

PostScript

Да, PostScript - это язык программирования. Кроме того, это язык программирования, где все языковые конструкции являются системными функциями, которые могут быть переопределены ...

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

По-английски:

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

С этого момента каждая команда языка PostScript определена, чтобы ничего не делать. AFAIK, невозможно выйти из этого состояния.

(Технически, вы не «уничтожаете» старые определения, вы просто затеняете их. Если бы вы все еще могли выполнить end, это выскочило бы Magicиз стека словаря, не затеняя все команды и вернув вам жизнь. Но так как endсама тоже затенена ... сейчас ничего не поделаешь.)

Обратите внимание, что все команды будут по-прежнему выполняться ... просто теперь они определены, чтобы ничего не делать. Вы не получите никакой ошибки, просто ничего не произойдет. (Ну, я полагаю, что переполнение стека произойдет в конце концов ...)

MathematicalOrchid
источник
Это на самом деле довольно забавно ... и тоже страшно ...
Грифон
34

Любая программа, выполняющаяся под 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, но вам, возможно, придется широко использовать белый список системных вызовов, а также бороться с расхождениями. в 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));
    }
  }
}
zwol
источник
1
«Цель может прочитать свои аргументы командной строки, выполнить чистые вычисления и произвести 8-битное состояние выхода, но не сможет выделить память или выполнить ввод / вывод» - я не знаю, я думаю, что вы все еще соответствуете четырем критериям , Целые числа могут быть интерпретированы из аргументов командной строки; статус выхода может быть использован для простого вывода; сложение не мешает; и все, что вам нужно для теста на простоту, - это способность делать чистые вычисления, немного места в стеке и цикл.
Blacklight Shining
1
@ BlacklightShining Я думаю, что это накладывает такое огромное ограничение по отношению к нормальному поведению, что оно должно быть приемлемым, даже если, как вы говорите, вы все равно можете написать главного тестера, но -DNO_EXITрежим предназначен для людей, которые чувствуют то же, что и вы. В этом режиме невозможен значимый вывод.
Звол
1
@ BlacklightShining Я еще немного подумал и переписал программу в основном с нуля. Теперь он гораздо умнее и (я надеюсь) отвечает даже самым строгим требованиям.
zwol
2
@ Joshua Это умно, и было бы трудно предотвратить использование этого подхода (поскольку программа просто изменяет свою собственную память), но в настоящее время его нет в списке «разрешенных методов вывода».
zwol
6
@JesseTG Вы знакомы с strace?
zwol
30

TeX

\catcode`\\=10

Я не уверен, что это на самом деле сработает, но в теории это должно сломаться \как побег персонажа, не оставив вам никакого способа это исправить. Обычно TeX может читать и записывать файлы, теперь он не может писать ничего, что зависит от логики. Таким образом, язык теперь нарушен, как определено OP.

РЕДАКТИРОВАТЬ: Другие команды уничтожения, взятые из комментариев (хотя обе могут нарушать правило «код должен быть выполнен»):

Cephalopod
источник
3
Лучший вариант: \def\fi{}\iffalse. Я не могу публиковать ответы на это, потому что для этого требуется не менее 10 повторений, заработанных на этом сайте, но это больше не позволит выводить данные.
user530873
1
@smpl, ты все еще можешь переопределить \fiего первоначальное значение, верно? Таким образом, язык не сломан без какого-либо ремонта.
Головоногий
1
@Cephalopod \fi- это примитив TeX. И нет, вы не можете ничего переопределить в этот момент, \iffalseбыл призван.
user530873
1
@ smpl Хм, я вижу. Очень умно.
Головоногий
1
+1. Я только начал учить себя вне TeXBook, и когда я понял, \catcode13=9%что полностью нарушил бы язык (все, что после %комментируется, а символы новой строки (ASCII char 13) игнорируются, поэтому комментарий распространяется на бесконечность), я хотел опубликовать его здесь. Но у вас есть немного более длинная команда уже здесь.
Iwillnotexist Idonotexist
29

царапать

Сломать скретч изображение
Он 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

wizzwizz4
источник
+1 Также может быть интересно запустить атомарный блок (запустить без обновления экрана) stop this script: P
Florrie
Как работает этот « when I receiveглюк»?
Scimonster
@Scimonster Шляпный when I receiveблок предназначен только для ввода данных из выпадающего списка. join[][]Блок возвращает тип данных , что when I recieveблок не предназначен для подтверждения. Каждый раз, когда что-то передается, все шляпные блоки проверяют и оценивают возвращаемое значение блока, выдавая incorrect typeошибку.
wizzwizz4
Понимаю. Хотя вам нужно взломать JSON-файл, чтобы получить joinблок.
Scimonster
1
@ppperry Это зависит от версии Flash, которая игнорирует ошибки - она существует. Взятый до крайности, «для достаточно малых n» можно использовать, чтобы сказать, что (n-1)работает для положительного n<3, но, поскольку это основано на алгоритме, хороший алгоритм должен быть в состоянии сделать nдостаточно большим, чтобы можно было игнорировать этот аргумент. Я не уверен, что более быстрая или медленная машина сделает ее более удобной в использовании. Тем не менее, я согласен, что это решение можно обойти. Это не полицейские и грабители , но, в любом случае, молодцы.
wizzwizz4
27

Mathematica / Wolfram Language

Mathematica - это интерпретируемый язык, в котором имена команд являются символами, которыми может манипулировать программист. Вы не можете удалить встроенные операторы, но вы можете перегрузить их или иным образом изменить их функцию. Следующее шифрует команду «С», которая необходима для присваивания переменных даже внутренне. Это изменение не позволяет ядру удерживать аргументы без оценки до тех пор, пока назначение не будет завершено, и это убивает язык совершенно мертвым.

ClearAttributes["With", HoldAll]

Если эта команда выполняется в интерактивном сеансе или в блоке кода, Mathematica даже не сможет добавить 1+1(итоговое сообщение об ошибке занимает около страницы, поэтому я не буду включать его здесь).

Майкл Стерн
источник
26

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

Фабиан Шменглер
источник
Существуют и другие допустимые формы вывода, включая запись в файлы и использование кода завершения программы. Смотрите ссылку в соответствующем пункте спецификации.
Мартин Эндер
1
Что именно разрешено и не было для меня не очевидно. Например, в теге wiki я ничего не нашел о файлах и кодах выхода. Но если им позволят, я не думаю, что смогу превратить это в действительное представление.
Фабиан Шменглер
Отредактировал вопрос, чтобы разрешить отключение только одной формы вывода.
jimmy23013
20
@ jimmy23013 что? Это полностью противоречит сути вопроса.
Хоббс
5
@ jimmy23013 Если допустимо просто отключить только одну выходную форму, то, например, подавление кода завершения программы (как предложил Мартин) - это все, что мне нужно сделать, даже если язык полностью используется без кода выхода?
Джерри Иеремия
24

Пакет DOS (до Windows 95, я верю)

CTTY

Выдается без аргументов, это отключает командную строку от терминала. Любые дальнейшие попытки чтения ввода или генерации вывода ничего не делают.

Если вы хотите знать, как правильно использовать CTTY:

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

Несколько более мощный пакетный файл может даже отвечать на модем и подключать все, что было набрано, к CTTY.

Джошуа
источник
23

Common Lisp

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

Я надеюсь, что вам не нужны эти вводные скобки.

Это макрос для чтения, который сообщает Lisp Reader о необходимости замены каждого экземпляра (вызовом (lambda (x y) ())функции, которая принимает два аргумента и ничего не возвращает. Так, например, он будет читать (foo)как foo), интерпретировать fooкак переменную и затем выдавать непревзойденную ошибку в скобках 0.

Свечи
источник
2
Пожалуйста, также интерпретировать )как что-то бред! Таким образом, будет меньше ошибок.
wizzwizz4
7
Мне это нравится. «На что полагается lisp? Один символ? Было бы стыдно, если что-то ... случилось с ним ...» Это та же логика, что и при переопределении `\` в TeX.
Феликсфью
23

царапать

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

Мгновенное падение

Я оставил его включенным примерно на двадцать секунд, а затем потерял 2,65 ГБ памяти для Scratch. Мгновение спустя и 5 Гбайт уже не было.

Я настоятельно рекомендую вам воспользоваться средством принудительного выхода из Adobe Flash или веб-браузера перед запуском этого!


Я действительно хотел сделать крутой ответ, как clear(this)JS, но, к сожалению, у Scratch нет никаких способов сделать это. Не стесняйтесь обновлять этот пост (или сделать свой собственный), если вы действительно находите другой способ сделать Scratch непригодным для использования!

Флори
источник
2
Куда вы добавляете код пользователя и выполняется ли он на самом деле?
jimmy23013
Код пользователя? В любом месте проекта, пока этот фрагмент вставлен. Он выполняется один раз через 0,3 секунды после первоначального запуска, а затем каждые 0,3 секунды (за исключением того, что он также постоянно перезапускает сценарий без конца, делая Scratch очень медленным). Это нормально, если я обновлю этот пост более мощным и мощным крушителем?
Флорри
5
Кто-то использует Scratch ... d: -D YAY !!!
wizzwizz4
@towerofnix Кстати, я улучшил / радикально изменил / воссоздал это здесь: codegolf.stackexchange.com/a/61490/43394 Мой не зависит от того, включен ли микрофон.
wizzwizz4
1
@ wizzwizz4 Да, ваш намного лучше, чем мой. пожалуйста, проголосуйте его
Флорри
20

Thue

::=

С новой строкой в ​​конце

Язык thue опирается на определение наборов правил, а a ::=обозначает конец набора правил. Невозможно сделать НИЧЕГО в течение этого времени без определения правил, которые делают это, поэтому независимо от того, что вы поставили после ::=, ничего не может произойти.

Альтернативный ответ

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

(и так далее для каждого символа во всем Unicode, включая символы перед Aсимволом и непечатные символы). Для этого требуется опция командной строки -r.

pppery
источник
Я думаю, что текст грамматически не то же самое, что что-то удовлетворяет критериям (например, набор правил).
jimmy23013
16

MATLAB

Следующий фрагмент кода делает среду полностью непригодной 1 :

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, который первоначально обнаружил эту идею.

rayryeng
источник
2
В R2014b вы можете это feval('clear')исправить. Или: s=str2func('clear'); s().
Стьюи Гриффин
13

///

/\///

Единственная операция , в /// повторяется строка подстановки, например: /pattern/replacement/.

Этот код удаляет все /, таким образом, вы не можете использовать повторную подстановку строк, поэтому в основном все, что вы пишете после этого, будет напечатано (кроме /s).

Вы все еще можете использовать \s, но это вам мало поможет.

акролит
источник
Я всегда задавался вопросом, возможно ли написать фрагмент кода ///, который гарантированно сотрет все после себя и, таким образом, остановится, ничего не печатая. Это кажется невозможным, но я не думал о доказательстве того, что это невозможно.
Таннер Светт
12

Befunge-96

'~h

Код пользователя может следовать в любом месте после этой последовательности, если это первые три символа в источнике.

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

Если для дельты задано значение 126, единственной действительной командой, которая может быть сгенерирована, является ~(ввод символов) через нулевой байт в источнике. Все, кроме нулевого байта, будет преобразовано в значение, превышающее 126, и ни одно из этих значений не будет допустимым для команд Befunge.

Я думаю, можно с уверенностью сказать, что это лишило бы его права квалифицироваться как язык программирования.

Джеймс Холдернесс
источник
11

Бу

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

А потом, где-то еще в проекте,

harmless

Простой макрос с безобидно звучащим названием, но удивительно разочаровывающим эффектом. Компилятор Boo использует многошаговый конвейер, который начинается с разбора исходного кода в AST и заканчивается генерацией кода. (Как правило, его можно перенастроить для различных приложений.) Каждый промежуточный шаг выполняет различные операции над AST.

На полпути проходит стадия расширения макроса, на которой макросы выполняются в контексте компилятора. Помните немного в последнем параграфе о том, что конвейер можно перенастроить? Если во время раскрытия макроса вы вызываете макрос, который очищает конвейер, пользователю не будет отображаться ошибка, но все шаги после раскрытия макроса (включая генерацию кода) больше не будут выполняться. Таким образом, в результате получается что-то, что выглядит как успешная компиляция - сообщения об ошибках не отображаются - но по какой-то причине не создается двоичный файл! Гарантировано, что даже самые лучшие специалисты по устранению неполадок будут доведены до уровня стены, если вы будете хорошо скрывать макрос и вызов.

Мейсон Уилер
источник
Этот ответ недействителен, так как код пользователя никогда не выполняется.
pppery
@ppperry: Конечно, это так: макрос может быть написан как часть пользовательского кода, и он выполняется внутри компилятора .
Мейсон Уилер
Вы должны будете определить такой макрос для символа набора символов, который должен быть напечатан в каждой отдельной программе или наборе программ, которые делают boo подходящим для критериев .
pppery
@ppperry: да, вызов макроса (в любом месте кода) - это то, что заставляет компилятор сломаться, выполняя критерии. Если вы пытаетесь сказать что-то более глубокое, вам нужно быть немного более ясным, потому что я не понимаю, в чем проблема.
Мейсон Уилер
2
@slebetman: И когда у вас есть REPL или макросы, где пользовательский код выполняется во время компиляции, различие между ними становится очень размытым.
Мейсон Уилер
10

СПП / АПЗ

NGN / APL позволяет переопределение примитивы, поэтому переопределение ( ) все примитивные функции ( «пройти через»: как ⊢3и 2⊢3дает 3) делает язык совершенно бесполезен:

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

Попробуй это здесь.

Адам
источник
1
-1 на данный момент, но это кажется многообещающим! Может быть, если вы переопределите все примитивы ...
Blacklight Shining
@BlightlightShining Вот, пожалуйста.
Адам
8

Рубин (29 символов)

class Object;def send;end;end

Как и «send» используется внутренне всякий раз, когда метод вызывается в Ruby, и поскольку все объекты наследуются от класса Object. Это должно остановить любой метод запуска.

Интересный факт: это совершенно правильно в теории. Но, похоже, почему-то не мешает языку Ruby. Я понятия не имею, почему можно запустить этот код, а затем по-прежнему использовать открытую среду Ruby.

AJFaraday
источник
На самом деле это работает в оболочке Pry Ruby.
Феликс Сапарелли
Вы имеете в виду, что это работает как в «это ломает это» или это работает как в «это все еще работает после этого»? Только я упомянул второй случай в простом старом ирб
AJFaraday
1
Я имею в виду, это ломает Прай. Он не нарушает IRB и не нарушает работу в файлах .rb, но он нарушает Pry.
Феликс Сапарелли
Интересно. Я предполагаю, что есть некоторая защита в методе send, который не работает в pry.
AJFaraday
8

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 нет ключевых слов, только функции)

slebetman
источник
1
Я думаю, что вы можете сделать это лучше, переименовав ifи renameпосле цикла. Во второй версии вы также должны сделать procисключение.
jimmy23013
@ jimmy23013 Хм .. технически вы должны быть правы, но этот фрагмент кода работает с текущей версией tcl, даже если он procпоявился в списке ранее puts. Технически код также должен работать без, renameно встроенные команды, похоже, защищены в противном случае. Не уверен, что происходит, но код протестирован и работает как рекламируется.
Slebetman
@ jimmy23013: ОК. Код теперь работает без необходимости звонить rename. С моей стороны это было нелепо - я забыл исключить proc.
Slebetman
Я решил не переименовывать, ifпотому что возможность делать это ifсамостоятельно бесполезна, если вы хотите генерировать вывод.
Slebetman
Конечно, вам не нужно переименовывать их. Но это не код-гольф. Я просто думал, что переименование их может (или не может) сделать этот ответ лучше.
jimmy23013
7

Hoon

=<  ~
(your code)

Хун странный. Это почти полностью отличается от других языков программирования, не только в синтаксисе, но и в семантике. В отличие от таких языков, как гексагония, она не была специально сделана эзотерической.

Hoon компилируется в Nock , минимальную виртуальную машину на основе комбинатора. Нок глуп: спецификация может быть сжата до 340 байтов. Единственная математическая операция - приращение. Все является существительным: атом (bignum) или клетка (пара существительных) со всей моделью памяти, расположенной в неизменном ациклическом двоичном дереве. Единственный вывод - это существительное, к которому сводится ваше выражение.

Из-за странной цели компиляции, Hoon также странный: он абсолютно чистый. Hoon компилируется в выражение Nock, которое оценивается в «контексте». Все ядро ​​и stdlib, вместе со всеми переменными, неявно передаются программе контекстом.

Чтобы сделать Hoon непригодным для использования, мы просто используем =<«оценить a в контексте b». Мы всегда оцениваем ~, что равно нулю. Независимо от того b, что делает, он не может изменить значение, к которому он уменьшает, и, поскольку у него не может быть побочного эффекта, он не может выполнять ввод или вывод.

Примечание: поскольку на самом деле вы не можете запрашивать ввод от Hoon (чистота!), По правилам это на самом деле не язык программирования. Ввод осуществляется с помощью аргументов функции, вывод - через возвращаемые значения (или ~&, что больше относится к функции отладки printf и является прозрачным для программы).

Для программы, которая получает ввод в Urbit, вы на самом деле пишете программу, которая возвращает функцию, которая принимает ввод, и оболочка запрашивает от вашего имени и передает обратный вызов.

RenderSettings
источник
3
Определенно, язык программирования по нашим стандартам
кот
7

Такси, 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.
pppery
источник
6

JavaScript в браузере

Ну, по крайней мере, в IE11.

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

Запрещает запись в документ, запись в глобальную переменную и возврат из функции.

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

wizzwizz4
источник
Исключения все равно будут отображаться в консоли. Вы можете справиться с этим, делаяwindow.addEventListener('error',function(){});
Исмаэль Мигель
@IsmaelMiguel Теперь я не могу взять весь кредит! d ;-D
wizzwizz4
4
Это серьезно работает? Это не имеет никакого смысла: documentвсе равно должен быть доступен из внешней области в вставленного кода, и он не должен получить заменить до после того, как вставленный код не закончит выполнение.
Питер Тейлор
@PeterTaylor :-( Твоя логика нарушила мою теорию.
wizzwizz4
2
Это не легко
Питер Тейлор
6

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

Весь этот код ( __init__метод RExecкласса и всего ModuleImporterкласса) скопирован из стандартной библиотеки Python с небольшими изменениями.

pppery
источник
2
0.о что ... что ты сделал
кот
8064 bytesкстати
кошка
@ не то чтобы это был код гольф. Я мог бы играть в гольф по крайней мере 1000 байтов.
pppery
конечно, но вы сказали «безумно большой», так что я подумал, что заметил бы это
кошка