Machen Sie Ihre Sprache unbrauchbar

191

Versuchen Sie, Code in Ihrer Sprache zu schreiben, der unseren Kriterien als Programmiersprache nicht mehr entspricht.

Eine Sprache erfüllt unsere Kriterien (vereinfachte Version für diese Herausforderung), eine Programmiersprache zu sein, wenn:

  • Es kann Benutzereingaben lesen, die Tupel positiver Ganzzahlen darstellen.
  • Es können je nach Eingabe mindestens zwei verschiedene mögliche Ergebnisse ausgegeben werden.
  • Es können zwei positive ganze Zahlen verwendet und addiert werden (und das Ergebnis kann die Ausgabe beeinflussen).
  • Es kann eine positive ganze Zahl annehmen und entscheiden, ob es eine Primzahl ist (und das Ergebnis kann die Ausgabe beeinflussen).
  • Für diese Herausforderung wird jede Art von Ausgabe ignoriert , die keine zulässige Ausgabemethode für eine normale Herausforderung ist. Es spielt also keine Rolle, ob das Programm auch ein Musikstück abspielen oder über HTTP posten kann.
  • Update: Sie können auch eine oder mehrere der zulässigen Ausgabemethoden auswählen und alle anderen ignorieren. In den folgenden Kriterien müssen Sie jedoch überall dieselbe Definition verwenden. Und wenn Ihr Programm mehr als eine Ausgabemethode deaktivieren kann, ist dies mehr Gegenstimmen wert.

Beispiele dafür sind, dass es nicht in der Lage ist, alle Schleifenkonstrukte auszugeben, oder dass es nicht in der Lage ist, Primalitätstests durchzuführen und sicherzustellen, dass der Benutzer sie nicht wieder aktivieren kann.

Sie sollten einen Platz zum Einfügen von neuem Code lassen. Standardmäßig befindet es sich am Ende Ihres Codes. Wenn wir in Betracht ziehen , den Quellcode an dieser Stelle in Ihrer Antwort abzulegen und den vollständigen Code als vollständiges Programm auszuführen, sollte der Interpreter einer neuen Sprache die Kriterien nicht erfüllen.

Aber der eingegebene Code muss in einer solchen Art und Weise ausgeführt werden , wie eine Sprache , die Kriterien erfüllen:

  • Der eingefügte Code muss grammatikalisch mit etwas identisch sein (sagen wir, es ist ein Codeblock in den folgenden Kriterien), das im Allgemeinen die Kriterien erfüllt, aus der Perspektive derjenigen, die einen Syntax-Textmarker schreiben möchten. Es kann also nicht in einer Zeichenfolge, einem Kommentar usw. sein.
  • Der eingefügte Code muss tatsächlich so ausgeführt werden, dass er die Kriterien erfüllen soll. Es kann also nicht in einer nicht verwendeten Funktion oder sizeofin C sein, Sie können nicht nur einen nicht funktionalen Teil im Code ausführen und Sie können ihn nicht nach einer Endlosschleife usw. setzen.
  • Sie können die Anzahl möglicher grammatikalisch korrekter Programme, die auf diese Weise generiert werden, nicht begrenzen. Wenn es in der von Ihnen verwendeten Sprache bereits so etwas wie ein Längenlimit gibt, sollte es die Kriterien nicht erfüllen, auch wenn dieses Limit entfernt wird.
  • Sie können den Inhalt der Eingabe / Ausgabe nicht ändern oder "verbrauchen", aber Sie können verhindern, dass auf sie zugegriffen wird.
  • Diese Kriterien gelten normalerweise nur für Sprachen ohne explizite E / A:
    • Ihr Code sollte die Benutzereingabe (die Informationen beliebiger Länge enthält) an den eingefügten Code umleiten, wenn ein Codeblock die Benutzereingabe normalerweise nicht direkt / explizit in der von Ihnen verwendeten Sprache abrufen kann.
    • Ihr Code sollte den zurückgegebenen Wert des eingefügten Codes ausgeben, wenn ein Codeblock normalerweise nicht in der Lage ist, Dinge direkt / explizit in der von Ihnen verwendeten Sprache auszugeben.
    • Wenn Sie den zurückgegebenen Wert drucken und er in der von Ihnen verwendeten Sprache eingegeben ist, sollte der zurückgegebene Typ 2 verschiedene, praktisch mögliche Werte haben können. Beispielsweise können Sie den Typ struct {}oder struct {private:int x;}in C ++ nicht verwenden .

Dies ist ein Beliebtheitswettbewerb. Die Antwort mit der höchsten gültigen Bewertung (damit niemand einen Fehler entdeckt oder alle Fehler behoben werden) gewinnt.

Klarstellungen

  • Sie sollten den Code nicht in der Textform ändern, sondern können die Syntax ändern, bevor der Code interpretiert oder kompiliert wird.
  • Sie können andere Dinge tun, während der Code ausgeführt wird. Der Grund dafür, dass es die Kriterien nicht erfüllt, sollte im eingefügten Code selbst liegen. Es kann an der Störung eines anderen Threads liegen, aber nicht nur von einem anderen Thread getötet werden.
  • Alle Spezifikationen bedeuten im Grunde genommen, dass es grammatikalisch wahrscheinlich ist, dass sie die Kriterien erfüllen, wenn nicht alle eingebauten Funktionen geändert wurden, dies jedoch nicht tatsächlich tun. Es ist in Ordnung, wenn Sie nicht-grammatikalische Problemumgehungen finden, z. B. die korrekte Übergabe der Parameter an den Codeblock, aber dafür sorgen, dass sie nicht in irgendeiner Weise verwendet werden können.
  • Auch hier muss der eingefügte Code tatsächlich ausgeführt werden. Code nach einer Endlosschleife oder einem Absturz wird als "nicht tatsächlich ausgeführt" betrachtet und ist daher nicht gültig . Diese Antworten mögen interessant sein, aber es gibt bereits einige andere Endlosschleifen- oder Absturzfragen auf dieser Website, und Sie finden möglicherweise eine passendere Antwort. Wenn nicht, stellen Sie eine neue Frage. Beispiele für diese Fragen sind:

Bestenliste

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
quelle
Darf ich den Code vor der Ausführung ändern? Kann ich auch anderen Code ausführen, während ich den angegebenen Code ausführe?
Blue
21
Das hätte eine wirklich gute Herausforderung für Bullen und Räuber sein können, denke ich.
DankMemes
6
@DankMemes Einverstanden. So wie es aussieht, ist es viel zu vage, und die meisten Antworten würden ungültig, wenn eine Problemumgehung gefunden würde. CNR mit dieser Prämisse wäre entzückend.
Mego
3
Dann scheint es so zu sein, dass es in Sprachen mit expliziter Eingabe / Ausgabe erlaubt ist, völlig langweilige Dinge wie das Lesen und Verwerfen des Inhalts von stdin zu tun. Es schafft ein völlig unfaires Spielfeld, in dem einige Sprachen einen sorgfältigen Umgang mit der E / A für den eingegebenen Code erfordern und andere es Ihnen ermöglichen, die E / A für den eingegebenen Code zu verwerfen und abzulehnen.
Peter Taylor
1
Dürfen wir eine Sprache verwenden, die von Anfang an unbrauchbar ist? (JavaScript zum Beispiel)
12. Mai, 21.

Antworten:

319

JavaScript-Shell

Dadurch wird die Sprache vollständig unbrauchbar.

clear(this);

Ist es nicht schön, wie JavaScript eine so schöne Funktion hat, um sich selbst zu zerstören?


Das ist ganz einfach, die clearFunktion leert ein Objekt komplett. thisbezieht sich auf das globale Objekt, das alles löscht, einschließlich Konstruktoren und Funktionen.


Da dies löscht alles , tut alles , auch eine wörtliche definieren , wirft einen Fehler, so dass die Sprache völlig nutzlos: * REPL Umgebung nicht erforderlich. Verwendet die SpiderMonkey- Engine (Shell nicht Browser), die ursprüngliche JS-Engine.Beispielanwendung

Downgoat
quelle
4
Diese clearFunktion scheint eine SpiderMonkey-Shell-spezifische Ergänzung zu sein, keine generische JavaScript-Sache. Es erscheint sicherlich nicht in der ES5-Spezifikation § Funktionseigenschaften des globalen Objekts . Ich habe das mit probiert nodeund habe einen "ReferenceError: clear is not defined" bekommen. In der Chrome- und Firefox-Konsole clearlöscht die Funktion nur die Konsole, unabhängig davon, welche Argumente übergeben werden. Oder entspricht das von Ihnen verwendete Tool möglicherweise einer älteren ECMAScript-Version als 5.1?
Anko
2
Könnten Sie stattdessen die Aussage "Ist es nicht schön, wie JavaScript eine so schöne Funktion hat, um sich selbst zu zerstören" ändern? JavaScript hat diese Funktion nicht, nur die SpiderMonkey-Implementierung.
Anko
1
@Anko SpiderMonkey ist jedoch JavaScript und wird mit Firefox gebündelt (SpiderMonkey ist die JS-Engine von Firefox). Ich werde später eine Version für node.js usw. schreiben, wenn ich Zeit habe
Downgoat
6
Ich denke, Sie verwechseln JavaScript (die Sprache) mit SpiderMonkey (eine der vielen Implementierungen der Sprache ). Extreme Allegorie: Während ich eine verrückte Implementierung von C schreiben könnte , in der alle Aufrufe von undefiniertem Verhalten zum Ausdruck des vollständigen Textes der Menschenrechtserklärung führen, wäre ich wahrscheinlich nicht in der Lage zu argumentieren, dass mein C-Beitrag "Golf the UDHR" ist "dass nur ein Nullzeiger dereferenziert wird, ist eine gültige C - Lösung. :)
Anko
8
@Anko Gemäß einer Site-Regel wird eine Sprache durch ihre Implementierung definiert. Wenn eine Antwort in mindestens einer Implementierung, die vor der Frage veröffentlicht wurde , konsistent funktioniert , ist sie akzeptabel. Sehen Sie hier und hier . (Der Code ist also gültig. Aber ich werde diesen speziellen Wortlaut nicht kommentieren.)
jimmy23013
169

Emmental

;#33!

Ich weiß, das ist kein Code-Golf, aber das richtige Werkzeug für den Job, weißt du ...

Der Benutzercode kann nach dem eingefügt werden !.

Emmental ist ein interessanter Esolang, der auf dem Umschreiben des Interpreten basiert . Jedes einzelne Symbol (auch die eingebauten) kann als beliebiges Emmentaler Programm neu definiert werden. Die Sprache stützt sich so sehr auf diese Funktion, dass sie keine Schleifenkonstrukte bietet. Stattdessen definieren Sie rekursive Befehle, die in eigenen Definitionen angezeigt werden.

Diese Neudefinition erfolgt über !, der ein Zeichen aus dem Stapel liest und dann eine Zeichenfolge aus dem Stapel liest, bis er auf a trifft ;. Das Zeichen wird dann neu definiert, um das durch diese Zeichenfolge dargestellte Programm zu bezeichnen.

Das heißt, wir können die Looping-Funktionen von Emmental deaktivieren, indem wir uns ! selbst als leeres Programm definieren. Während alle anderen Emmentaler noch einwandfrei funktionieren und viele der Kriterien einer Programmiersprache noch erfüllt sind, ist es unmöglich, weitere Symbole neu zu definieren. Ohne diese Funktion (und damit ohne Schleife) kann Emmental nicht mehr testen, ob eine Zahl eine Primzahl ist.

Martin Ender
quelle
49
Deaktivieren Sie das einzige definierende Merkmal der Sprache: pure Genialität. Dies ist sicherlich das richtige Werkzeug für den Job. +1
ETHproductions
93

PHP

Man kann PHP komplett beenden, indem man das Speicherlimit auf 1 setzt.

Es wird komplett sterben.

Versuche dies:

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

    //code here

Dies sollte nicht einmal einen Fehler auslösen, da dafür nicht genügend Speicher vorhanden ist.

Sie können mehr über die Richtlinie lesenmemory_limit


Wenn der vorherige ungültig ist, kann man Ausgabepuffer verwenden:

<?php
    ob_start();

    //code here

    ob_clear();

Dadurch werden alle Ausgaben vollständig entfernt. Da der Ausgabepuffer noch offen ist, werden einige andere Dinge, die versehentlich nach dem Code übrig bleiben, nicht angezeigt.


Mit @fschmenglers Idee:

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

Dies vermeidet das Problem des Löschens des automatisch gestarteten Ausgabepuffers, der zum Auffangen der zu komprimierenden Ausgabe verwendet wird.

Dies verhindert auch, dass der Ausgabepuffer gelöscht oder geleert (an den Browser gesendet) wird. Um dies erneut zu erzwingen, wird ein Ausgabehandler hinzugefügt, der immer eine leere Zeichenfolge zurückgibt.
Laufen ob_end_flush(); echo "Hello, world!";erzeugt nichts, sondern sendet die Ausgabe mit einer Ebene ob_start();.

Vielen Dank an @LucasTrzesniewski für die Veröffentlichung dieses Problems!

Ismael Miguel
quelle
1
Da Sie mehrere Ausgabepufferebenen haben können, funktioniert die zweite nicht. Wird while(ob_get_level()) ob_end_flush();häufig in Frameworks verwendet, um alle Ausgabepuffer zu leeren, die möglicherweise versehentlich offen gelassen wurden.
Fabian Schmengler
@fschmengler Dies führt zu Problemen mit automatisch geöffneten Ausgabepuffern, die normalerweise zum Komprimieren der Ausgabe mit gzip verwendet werden. Was wiederum den Zweck zunichte macht.
Ismael Miguel
Dies kann umgangen werden mit:ob_end_flush(); echo "Hello, world!";
Lucas Trzesniewski
8
Warum wundert es mich nicht, dass PHP ganz oben auf der Abstimmungsliste
gelandet ist
47
This shouldn't even throw any error, since there isn't enough memory for that.LOL'ed at that :)
ETHproductions
91

x86-Maschinencode im Real-Modus (=> fast jedes DOS-Programm)

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

dh

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

Ich hoffe, du warst nicht zu sehr an deinem Interrupt-Tisch hängen.

Matteo Italia
quelle
75
Sir, wenn ich Sie für ein paar Zyklen unterbrechen darf, damit ich ...
Luminous
6
Was ist, wenn die erste Anweisung meines eingefügten Codes lautet cli, und ich dann die Interrupt-Tabelle behebe und dann einige Primzahlen usw. berechne?
Nate Eldredge
3
@NateEldredge: Der nächste Schritt besteht darin, den Rest des Codes auf Ring 3 ohne Trampolin zurück auf Ring 0 zu setzen. Ich werde sehen, ob ich es schaffe, ein funktionierendes Beispiel zusammenzustellen (eine andere Möglichkeit wäre, den gesamten Adressraum zu scannen und den gesamten NOP-Out durchzuführen cli( inpund das outpnur aus gutem Grund), aber ich weiß nicht, ob das zulässig wäre nach den Regeln
Matteo Italia
2
Zumindest wird dies ein Programm nicht davon abhalten, direkt in den Bildschirmpuffer zu schreiben (was unter DOS ziemlich häufig war).
Jerry Coffin
1
@NateEldredge: Die Regeln sind in dieser Hinsicht nicht wirklich klar, und wenn Sie sich umsehen, bestehen die meisten Antworten tatsächlich aus Änderungen an der Umgebung, die bei trivialen Anweisungen einen Laufzeitfehler erzeugen (JS clear(this);, Speicherlimit in PHP, Rekursion) Limit in Python, die Sandbox-Umgebung in Python und viele andere), würde ich dies nicht als Problem sehen.
Matteo Italia
68

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

Edit: Gegenmaßnahmen machen diesen Riesen :(

Leitet stdin und stdout zu Null-Streams um und ersetzt args durch ein leeres Array. Verwendet auch enorme Mengen an Reflection-Hacks, um sicherzustellen, dass das Standard-E / A wirklich verborgen ist. Schließlich wird ein Sicherheitsmanager festgelegt, der sicherstellt, dass die Standard-E / A nicht neu erstellt werden kann und dass Programme den Beendigungscode nicht festlegen können.

DankMemes
quelle
6
Negativ.
Mego
10
+1 Ich persönlich betrachte die / proc-Problemumgehungen nicht als echte Deal Breaker, da ich kein Linux verwende und weder mein Unix-Betriebssystem noch mein Windows-Betriebssystem ein / proc-Dateisystem haben.
Jerry Jeremiah
67
Bisherige Zusammenfassung dieser Herausforderung: 1. JavaScript, 12 Zeichen. 2. Emmentaler, 6 Zeichen. 3. x 86, 12 Bytes. 4. Python, 42 Zeichen. 5. Java, 2264 Zeichen ! Warum bin ich nicht überrascht?
hörte
34
@ceasedtoturncounterclockwis Es liegt daran, dass Java sicherer ist und es daher schwieriger ist zu brechen: D
Pierre Arlaud
62

Lua

_ENV=""

In Lua _ENVist die Umgebung, in der alle globalen Variablen, Funktionen, Tabellen usw. gespeichert sind. Wenn Sie festlegen, dass es sich nur um eine leere Zeichenfolge handelt, können Sie nichts Neues definieren und alle Funktionen und Variablen werden gelöscht. Dies bedeutet, dass Sie nichts ausgeben, Eingaben übernehmen oder so ziemlich alles tun können.

TreFox
quelle
1
Hat _ENV=5zu arbeiten? Wenn ja, ist es ein Zeichen kürzer.
immibis
7
@immibis Stimmt, aber dies ist ein Beliebtheitswettbewerb, kein Code-Längen-Wettbewerb. PS - Vertraue darauf, dass du die Lua-Antwort erfährst.
Pharap
+1 für Lua. Macht $ _G = nil $ nicht auch mehr oder weniger dasselbe?
Doddy
@Doddy Nein, weil _G nur eine Kopie von _ENV ist, mit der Sie Variablen und ähnliches nachschlagen können - es ist eigentlich nicht die Umgebung. Sie könnten jedoch _G = nil und dann die Umgebung auf _G setzen, und das hätte den gleichen Effekt.
TreFox
Nicht ganz richtig. Wenn Sie irgendwo in der lokalen Variablen ein Backup haben, können Sie es wiederherstellen. Und Sie können weiterhin lokale Variablen definieren und sogar Funktionen aufrufen, die sich auf Zeichenfolgen beziehen!
val
46

Shakespeare-Programmiersprache

Have Fun Mr Parser.

Romeo, a young man of Verona.
Juliet, a young lady of Verona.
Hamlet, another character which causes the crash.

Act I
Scene I The crash.

[Enter Romeo]
[Enter Juliet]
[Exit Hamlet]

In SPL folgt der eingebaute Parser, der mit dem Programm heruntergeladen wird, sehr spezifischen Regeln, was im Skript passieren kann. Eine dieser Regeln ist, dass nur zwei Charaktere gleichzeitig auf der Bühne stehen dürfen. Wenn ein Charakter die Bühne verlässt, der noch nie auf der Bühne war, wird dies ebenfalls verwirrend sein. Das gleiche gilt für das Hinzufügen eines Charakters zur Bühne, der sich bereits auf der Bühne befindet. Wenn der Parser eine Fehlermeldung erhält, weigert er sich, etwas anderes zu tun. Sie müssen das Programm und den Parser buchstäblich komplett herunterfahren und dann alles neu starten.

PS Wenn Sie keine Ahnung haben, wie diese Sprache funktioniert, Google es. Es ist toll.

3.14ed_Piper
quelle
1
Handelt es sich also um einen Analyse- oder einen Laufzeitfehler?
Fabian Schmengler
4
@fschmengler Das ist im Grunde das Gleiche für interpretierte Sprachen.
NWP
13
Wenn ich Code nach der letzten Zeile hinzufüge, wird er dann tatsächlich ausgeführt ?
Sp3000
@ Sp3000 Es wird sicherlich versuchen ...... es wird so aussehen, als ob nichts Ungewöhnliches passiert ist ... bis der Parser abstürzt. :)
3.14ed_Piper
43

Smalltalk

Ich bin nicht sicher, ob dies qualifiziert ist:

Smalltalk := Nil.

Dadurch wird die gesamte Laufzeitumgebung gelöscht und die Objekt-Engine aufgehängt. Die einzige Möglichkeit, dies zu beheben, besteht darin, den Prozess gewaltsam zu beenden und von der Sicherung aus neu zu starten.

Für diejenigen, die es nicht wissen, ist die Funktionsweise von [Visual Works] Smalltalk etwas seltsam. Es ist wie ein Mini-OS. Wenn Sie Smalltalk starten, laden Sie ein "Speicherabbild" in den Arbeitsspeicher und es wird dort ausgeführt, wo es aufgehört hat. Die gesamte Smalltalk-IDE ist in Smalltalk geschrieben und kann dynamisch geändert werden.

Insbesondere Smalltalkist ein Wörterbuch mit allen globalen Variablen. Insbesondere wird jedes Mal, wenn Sie eine neue Klasse deklarieren, eine globale Variable mit diesem Namen erstellt, die auf das ClassObjekt für Ihre neue Klasse verweist . So Einstellung Smalltalkzu Nil(im Wesentlichen null) löscht alle Klassen in der gesamten Anlage. Sogar die GUI-Event-Handler sind patzig.

Ich habe keine Ahnung, warum diese Variable überhaupt beschreibbar ist. Wahrscheinlich, weil es eine globale Variable ist und daher als ein Eintrag in sich selbst existiert. (Tut dein Kopf schon weh? Habe ich erwähnt, dass jedes Objekt eine Klasse hat und Klassen Objekte sind, also hat jede Klasse eine Klasse? Die Klasse einer Klasse heißt Metaklasse, aber eine Metaklasse ist auch ein Objekt, das hat also eine Klasse...)

Sie könnten wahrscheinlich einen ähnlichen Effekt durch erzielen Clearing das Wörterbuch nicht ersetzt sie durch null. In der Tat gibt es eine Reihe von Dingen, die Sie codieren können, um alle Klassen im System zu löschen, sodass Sie nichts mehr tun können. Aber da der eigentliche Smalltalk-Compiler auch eine Klasse ist ... alles, was die Sprache bricht, bricht auch irgendwie die gesamte IDE, also ...

MathematicalOrchid
quelle
Es ist ungültig, wenn es sich selbst aufhängt, aber nicht der nächste Befehl. Aber ich bin neugierig: Gibt es eine Klasse, bei der beide Werte eine Klasse und ein gewöhnliches Objekt sein können? Und eine Klasse, die diese beiden Werte und diese neue Klasse haben kann? Und eine Klasse für sich?
Jimmy23013
Eine Smalltalk-Klasse ähnelt vage einem JavaScript-Prototyp. Indem Sie die Systemklassen hart genug hacken, können Sie Smalltalk sogar in eine Mehrfachvererbungssprache verwandeln. Auch Methodenaufrufe sind Objekte, Codeblöcke sind Objekte ... Sie können undefinierte Methodenaufrufe abfangen und ausführen lassen ... es ist eine sehr dynamische Sprache. Alles ist ein Objekt! Einschließlich der IDE ...
MathematicalOrchid
1
Musste nilstatt Nilin Pharo verwenden.
Margarciaisaia
5
Eine andere ist true become: false, aber ich denke, dass dies in neueren Versionen der Sprache nicht funktioniert. Sie könnten SmallTalk / V 286 auf diese Weise töten.
15
„Habe ich erwähnt, dass jedes Objekt eine Klasse hat und Klassen Objekte sind, also hat jede Klasse eine Klasse? Die Klasse einer Klasse wird Metaklasse genannt, aber eine Metaklasse ist auch ein Objekt, das daher eine Klasse hat ... “Als Pythonist tut mir der Kopf überhaupt nicht weh. Im Gegenteil, ich glaube, ich würde mich bei Smalltalk wie zu Hause fühlen.
Blacklight Shining
40

Haskell

Hier gibt es einige Möglichkeiten.

Langweilige Idee Nr. 1: Definieren mainSie, nichts zu tun. Egal welchen anderen Code Sie schreiben, er kann niemals ausgeführt werden. (Es sei denn, Sie führen es manuell von der REPL aus.)

Langweilige Idee Nr. 2: Definieren Sie ein Modul ohne öffentliche Exporte. Egal welchen anderen Code Sie schreiben, er kann niemals ausgeführt werden.

Interessante Idee: Alle Importe deaktivieren.

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

Jetzt können Sie Funktionen definieren , die sind sichtbar und können ausgeführt werden ... aber sie können nichts tun. Alle Standard-Haskell-Typen und -Funktionen sind jetzt ausgeblendet. (Mit Ausnahme einiger Dinge, die wirklich fest mit der Sprache verbunden sind.)

Insbesondere können Sie keine E / A-Vorgänge ausführen. Sie können auch nicht maschinengenau rechnen. (Da Int, Doubleetc sind jetzt undefiniert.)

Sie können immer noch Lambda-Berechnungsfunktionen schreiben, die jedoch einige echte Berechnungen durchführen. Sie können einfach keine Daten in oder aus der Sache bekommen. Sie können aber natürlich auch ein anderes, separates Modul schreiben, das das Fubarobige Modul aufruft und in seinem Namen E / A-Vorgänge ausführt (um zu beweisen, dass der Code ausgeführt wird und bestimmte Aufgaben ausführt).

Einige Feinheiten:

  • Die Dummy- foo = fooDeklaration wird benötigt, um zu verhindern, dass weitere Importe hinzugefügt werden. (Importe können nicht nach Deklarationen angezeigt werden.)

  • Es gibt verschiedene nicht standardmäßige Haskell-Spracherweiterungen, mit denen Sie diese Situation überwinden können. Spracherweiterungen müssen jedoch mit einem Compiler-Pragma oben in der Datei aktiviert werden. (Oder mit einer Befehlszeilenoption zum Compiler. Ich kann das nicht wirklich verhindern!)

MathematicalOrchid
quelle
-0.1 Verwendung foobar, die von Ihnen verwendete Schreibweise hat einige ... unbeabsichtigte Konnotationen.
wizzwizz4
@ wizzwizz4 Ich bin mir ziemlich sicher, dass "foobar" nur "fubar" ist, um Zensuren zu vermeiden. Deshalb neige ich dazu, es in Programmierbeispielen zu vermeiden.
jpmc26
3
@ jpmc26 Tatsächlich hat es eine lange und bemerkenswerte Geschichte. Es durchlief eine MIT-Modellbahngruppe, wurde in einem Programmierbuch populär gemacht, bevor es in die Dokumentation aufgenommen und dann in die Populärkultur gebracht wurde. Ich bin mir ziemlich sicher, dass es ein Zufall ist.
wizzwizz4
Beide "langweiligen Ideen" sind ungültig, da der Benutzercode nicht tatsächlich ausgeführt wird. (Die "interessante Idee" scheint jedoch gültig zu sein)
pppery
40

Nachsatz

Ja, PostScript ist eine Programmiersprache. Darüber hinaus ist es eine Programmiersprache, in der alle Sprachkonstrukte systemdefinierte Funktionen sind, die neu definiert werden können ...

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

Auf Englisch:

  • Erstellen Sie ein leeres Wörterbuch mit 1.000 Elementen und benennen Sie es Magic.
  • Fügen Sie für jede systemdictEingabe denselben Schlüssel Magicmit einer leeren Definition (" {}") hinzu.
  • Schieben Sie es Magicoben auf den Wörterbuchstapel.

Von diesem Moment an ist jeder PostScript-Sprachbefehl so definiert, dass er nichts mehr tut. AFAIK, es ist unmöglich , aus diesem Zustand zu entkommen.

(Technisch gesehen "zerstören" Sie die alten Definitionen nicht, Sie schattieren sie nur. Wenn Sie sie noch ausführen könnten end, würde dies Magicden Dictionary-Stack verlassen, alle Befehle deaktivieren und Ihnen Ihr Leben zurückgeben. Aber seitdem endselbst ist auch beschattet ... es wird jetzt nichts mehr tun.)

Beachten Sie, dass alle Befehle weiterhin ausgeführt werden . Sie sind nur so definiert, dass sie nichts tun. Sie werden keine Fehler bekommen, es ist nur so, dass nichts passieren wird. (Nun, ich nehme an, ein Stapelüberlauf wird irgendwann passieren ...)

MathematicalOrchid
quelle
Das ist eigentlich ein bisschen lustig ... und auch beängstigend ...
Gryphon
34

Beliebiges Programm, das unter Linux / x86 (-64) ausgeführt wird

Dieses Programm ist geschrieben in C, aber es kann unter Linux / x86 (-32 oder -64) Durchführung eines Programms läuft stören. Sie stellen es dem Befehlszeilenaufruf des Programms voran, das Sie unterbrechen möchten.

Es verwendet die Debugger-API, um zu verhindern, dass das Zielprogramm eine Ausgabe erzeugt. Insbesondere schlagen alle Systemaufrufe fehl, die der Welt außerhalb des Prozesses etwas mitteilen können (am offensichtlichsten writenatürlich, aber auch openbeim Erstellen einer Datei, der Großteil der Socket-API, killwenn sie auf einen anderen Prozess angewendet werden, ...) als wären sie nicht implementiert. _exitist erlaubt, aber der Exit-Code wird mit einer Null überschrieben.

Im Gegensatz zur vorherigen Ausgabe dieser Antwort können viele Programme unter diesen Bedingungen fast vollständig ausgeführt werden. Es ist nur so, dass all ihre Arbeit verschwendet wird. Wenn Sie dies beispielsweise tun ./no-syscalls /bin/ls(unter der Annahme, dass GNU coreutils vorhanden ist ls), wird das gesamte Verzeichnis gelesen und formatiert, und alle writeAufrufe zur Ausgabe schlagen fehl. (Alles , was einen bidirektionalen Kommunikationskanal zu öffnen , muss aber, wie alles X11 - Clients, wird an diesem Punkt scheitern. Ich dachte daran , damit socketaber nicht send, aber es schien zu wahrscheinlich Lücken zu öffnen.)

Es gibt verschiedene Befehlszeilenoptionen, um das Verhalten zu optimieren.

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

Dynamisch verknüpfte Programme verlassen im -eModus nicht einmal den Dynamic Linker . -SOffensichtlich öffnet sich eine riesige Lücke in der Politik, aber es kann unterhaltsam sein, Programme zu sehen, die über nichts stöhnen, was funktioniert, z

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

Sie müssen die Protokollausgabe mit /usr/include/asm*/unistd.hopen in einem anderen Fenster lesen , da dies bereits ziemlich lang genug ist.

Leider sind die verwendeten Debugger-Schnittstellen in allen Unix-Implementierungen nur schwach konsistent und von Haus aus CPU-spezifisch. Es wäre relativ einfach, es auf andere CPU-Architekturen zu portieren (fügen Sie einfach die entsprechenden Definitionen von hinzu SYSCALL_*_REG), und es ist wahrscheinlich möglich , es auf jedes Unix zu portieren ptrace, aber Sie müssen sich möglicherweise intensiv mit der Syscall-Whitelist auseinandersetzen und auch mit Divergenzen befassen in ptrace.

#define _GNU_SOURCE 1
#include <stddef.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/ptrace.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/user.h>
#include <sys/wait.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#if defined __linux__
# define SYS_unimplemented -1L
# if defined __i386__
#  define SYSCALL_NUMBER_REG regs.orig_eax
#  define SYSCALL_ARG1_REG   regs.ebx
#  define SYSCALL_ARG2_REG   regs.ecx
#  define SYSCALL_ARG3_REG   regs.edx
#  define SYSCALL_ARG4_REG   regs.esi
#  define SYSCALL_RESULT_REG regs.eax
# elif defined __x86_64__
#  define SYSCALL_NUMBER_REG regs.orig_rax
#  define SYSCALL_ARG1_REG   regs.rdi
#  define SYSCALL_ARG2_REG   regs.rsi
#  define SYSCALL_ARG3_REG   regs.rdx
#  define SYSCALL_ARG4_REG   regs.r10
#  define SYSCALL_RESULT_REG regs.rax
# else
#  error "Need to know system call convention for this CPU"
# endif
#else
# error "Need to know system call convention for this OS"
#endif

static long
xptrace(int request, pid_t pid, void *addr, void *data)
{
  errno = 0;
  long rv = ptrace(request, pid, addr, data);
  if (rv == -1 && errno) {
    perror("ptrace");
    if (pid != 0) kill(pid, SIGKILL);
    exit(1);
  }
  return rv;
}
#define GET_REG_(pid, x) \
  xptrace(PTRACE_PEEKUSER, pid, (void*)offsetof(struct user, x), 0)
#define GET_REG(pid, x) GET_REG_(pid, SYSCALL_##x##_REG)
#define SET_REG_(pid, x, v) \
  xptrace(PTRACE_POKEUSER, pid, (void*)offsetof(struct user, x), (void*)v)
#define SET_REG(pid, x, v) SET_REG_(pid, SYSCALL_##x##_REG, v)

/* This function defines the system-call policy.  */
static int
deny_syscall(pid_t pid, int scnum, int deny_all, int allow_stderr)
{
  switch (scnum) {
  /* These syscalls are unconditionally allowed (when not in -e mode);
     they perform input, or change only process-local state. */
#ifdef SYS_access
  case SYS_access:
#endif
#ifdef SYS_alarm
  case SYS_alarm:
#endif
#ifdef SYS_arch_prctl
  case SYS_arch_prctl:
#endif
#ifdef SYS_brk
  case SYS_brk:
#endif
#ifdef SYS_capget
  case SYS_capget:
#endif
#ifdef SYS_clock_getres
  case SYS_clock_getres:
#endif
#ifdef SYS_clock_gettime
  case SYS_clock_gettime:
#endif
#ifdef SYS_clock_nanosleep
  case SYS_clock_nanosleep:
#endif
#ifdef SYS_close
  case SYS_close:
#endif
#ifdef SYS_dup
  case SYS_dup:
#endif
#ifdef SYS_dup2
  case SYS_dup2:
#endif
#ifdef SYS_dup3
  case SYS_dup3:
#endif
#ifdef SYS_epoll_create
  case SYS_epoll_create:
#endif
#ifdef SYS_epoll_create1
  case SYS_epoll_create1:
#endif
#ifdef SYS_epoll_ctl
  case SYS_epoll_ctl:
#endif
#ifdef SYS_epoll_ctl_old
  case SYS_epoll_ctl_old:
#endif
#ifdef SYS_epoll_pwait
  case SYS_epoll_pwait:
#endif
#ifdef SYS_epoll_wait
  case SYS_epoll_wait:
#endif
#ifdef SYS_epoll_wait_old
  case SYS_epoll_wait_old:
#endif
#ifdef SYS_eventfd
  case SYS_eventfd:
#endif
#ifdef SYS_eventfd2
  case SYS_eventfd2:
#endif
#ifdef SYS_faccessat
  case SYS_faccessat:
#endif
#ifdef SYS_fadvise64
  case SYS_fadvise64:
#endif
#ifdef SYS_fadvise64_64
  case SYS_fadvise64_64:
#endif
#ifdef SYS_fanotify_init
  case SYS_fanotify_init:
#endif
#ifdef SYS_fanotify_mark
  case SYS_fanotify_mark:
#endif
#ifdef SYS_fgetxattr
  case SYS_fgetxattr:
#endif
#ifdef SYS_flistxattr
  case SYS_flistxattr:
#endif
#ifdef SYS_fstat
  case SYS_fstat:
#endif
#ifdef SYS_fstat64
  case SYS_fstat64:
#endif
#ifdef SYS_fstatat64
  case SYS_fstatat64:
#endif
#ifdef SYS_fstatfs
  case SYS_fstatfs:
#endif
#ifdef SYS_fstatfs64
  case SYS_fstatfs64:
#endif
#ifdef SYS_ftime
  case SYS_ftime:
#endif
#ifdef SYS_futex
  case SYS_futex:
#endif
#ifdef SYS_getcpu
  case SYS_getcpu:
#endif
#ifdef SYS_getcwd
  case SYS_getcwd:
#endif
#ifdef SYS_getdents
  case SYS_getdents:
#endif
#ifdef SYS_getdents64
  case SYS_getdents64:
#endif
#ifdef SYS_getegid
  case SYS_getegid:
#endif
#ifdef SYS_getegid32
  case SYS_getegid32:
#endif
#ifdef SYS_geteuid
  case SYS_geteuid:
#endif
#ifdef SYS_geteuid32
  case SYS_geteuid32:
#endif
#ifdef SYS_getgid
  case SYS_getgid:
#endif
#ifdef SYS_getgid32
  case SYS_getgid32:
#endif
#ifdef SYS_getgroups
  case SYS_getgroups:
#endif
#ifdef SYS_getgroups32
  case SYS_getgroups32:
#endif
#ifdef SYS_getitimer
  case SYS_getitimer:
#endif
#ifdef SYS_get_kernel_syms
  case SYS_get_kernel_syms:
#endif
#ifdef SYS_get_mempolicy
  case SYS_get_mempolicy:
#endif
#ifdef SYS_getpeername
  case SYS_getpeername:
#endif
#ifdef SYS_getpgid
  case SYS_getpgid:
#endif
#ifdef SYS_getpgrp
  case SYS_getpgrp:
#endif
#ifdef SYS_getpid
  case SYS_getpid:
#endif
#ifdef SYS_getpmsg
  case SYS_getpmsg:
#endif
#ifdef SYS_getppid
  case SYS_getppid:
#endif
#ifdef SYS_getpriority
  case SYS_getpriority:
#endif
#ifdef SYS_getrandom
  case SYS_getrandom:
#endif
#ifdef SYS_getresgid
  case SYS_getresgid:
#endif
#ifdef SYS_getresgid32
  case SYS_getresgid32:
#endif
#ifdef SYS_getresuid
  case SYS_getresuid:
#endif
#ifdef SYS_getresuid32
  case SYS_getresuid32:
#endif
#ifdef SYS_getrlimit
  case SYS_getrlimit:
#endif
#ifdef SYS_get_robust_list
  case SYS_get_robust_list:
#endif
#ifdef SYS_getrusage
  case SYS_getrusage:
#endif
#ifdef SYS_getsid
  case SYS_getsid:
#endif
#ifdef SYS_getsockname
  case SYS_getsockname:
#endif
#ifdef SYS_getsockopt
  case SYS_getsockopt:
#endif
#ifdef SYS_get_thread_area
  case SYS_get_thread_area:
#endif
#ifdef SYS_gettid
  case SYS_gettid:
#endif
#ifdef SYS_gettimeofday
  case SYS_gettimeofday:
#endif
#ifdef SYS_getuid
  case SYS_getuid:
#endif
#ifdef SYS_getuid32
  case SYS_getuid32:
#endif
#ifdef SYS_getxattr
  case SYS_getxattr:
#endif
#ifdef SYS_inotify_add_watch
  case SYS_inotify_add_watch:
#endif
#ifdef SYS_inotify_init
  case SYS_inotify_init:
#endif
#ifdef SYS_inotify_init1
  case SYS_inotify_init1:
#endif
#ifdef SYS_inotify_rm_watch
  case SYS_inotify_rm_watch:
#endif
#ifdef SYS_ioprio_get
  case SYS_ioprio_get:
#endif
#ifdef SYS_kcmp
  case SYS_kcmp:
#endif
#ifdef SYS_lgetxattr
  case SYS_lgetxattr:
#endif
#ifdef SYS_listxattr
  case SYS_listxattr:
#endif
#ifdef SYS_llistxattr
  case SYS_llistxattr:
#endif
#ifdef SYS_lookup_dcookie
  case SYS_lookup_dcookie:
#endif
#ifdef SYS_lseek
  case SYS_lseek:
#endif
#ifdef SYS_lstat
  case SYS_lstat:
#endif
#ifdef SYS_lstat64
  case SYS_lstat64:
#endif
#ifdef SYS_madvise
  case SYS_madvise:
#endif
#ifdef SYS_mbind
  case SYS_mbind:
#endif
#ifdef SYS_mincore
  case SYS_mincore:
#endif
#ifdef SYS_mlock
  case SYS_mlock:
#endif
#ifdef SYS_mlockall
  case SYS_mlockall:
#endif
#ifdef SYS_mprotect
  case SYS_mprotect:
#endif
#ifdef SYS_mremap
  case SYS_mremap:
#endif
#ifdef SYS_munlock
  case SYS_munlock:
#endif
#ifdef SYS_munlockall
  case SYS_munlockall:
#endif
#ifdef SYS_munmap
  case SYS_munmap:
#endif
#ifdef SYS_name_to_handle_at
  case SYS_name_to_handle_at:
#endif
#ifdef SYS_nanosleep
  case SYS_nanosleep:
#endif
#ifdef SYS_newfstatat
  case SYS_newfstatat:
#endif
#ifdef SYS_nice
  case SYS_nice:
#endif
#ifdef SYS_oldfstat
  case SYS_oldfstat:
#endif
#ifdef SYS_oldlstat
  case SYS_oldlstat:
#endif
#ifdef SYS_oldolduname
  case SYS_oldolduname:
#endif
#ifdef SYS_oldstat
  case SYS_oldstat:
#endif
#ifdef SYS_olduname
  case SYS_olduname:
#endif
#ifdef SYS_pause
  case SYS_pause:
#endif
#ifdef SYS_perf_event_open
  case SYS_perf_event_open:
#endif
#ifdef SYS_personality
  case SYS_personality:
#endif
#ifdef SYS_pivot_root
  case SYS_pivot_root:
#endif
#ifdef SYS_poll
  case SYS_poll:
#endif
#ifdef SYS_ppoll
  case SYS_ppoll:
#endif
#ifdef SYS_prctl
  case SYS_prctl:
#endif
#ifdef SYS_pread64
  case SYS_pread64:
#endif
#ifdef SYS_preadv
  case SYS_preadv:
#endif
#ifdef SYS_prlimit64
  case SYS_prlimit64:
#endif
#ifdef SYS_pselect6
  case SYS_pselect6:
#endif
#ifdef SYS_query_module
  case SYS_query_module:
#endif
#ifdef SYS_read
  case SYS_read:
#endif
#ifdef SYS_readahead
  case SYS_readahead:
#endif
#ifdef SYS_readdir
  case SYS_readdir:
#endif
#ifdef SYS_readlink
  case SYS_readlink:
#endif
#ifdef SYS_readlinkat
  case SYS_readlinkat:
#endif
#ifdef SYS_readv
  case SYS_readv:
#endif
#ifdef SYS_recvfrom
  case SYS_recvfrom:
#endif
#ifdef SYS_recvmmsg
  case SYS_recvmmsg:
#endif
#ifdef SYS_recvmsg
  case SYS_recvmsg:
#endif
#ifdef SYS_remap_file_pages
  case SYS_remap_file_pages:
#endif
#ifdef SYS_request_key
  case SYS_request_key:
#endif
#ifdef SYS_restart_syscall
  case SYS_restart_syscall:
#endif
#ifdef SYS_rt_sigaction
  case SYS_rt_sigaction:
#endif
#ifdef SYS_rt_sigpending
  case SYS_rt_sigpending:
#endif
#ifdef SYS_rt_sigprocmask
  case SYS_rt_sigprocmask:
#endif
#ifdef SYS_rt_sigreturn
  case SYS_rt_sigreturn:
#endif
#ifdef SYS_rt_sigsuspend
  case SYS_rt_sigsuspend:
#endif
#ifdef SYS_rt_sigtimedwait
  case SYS_rt_sigtimedwait:
#endif
#ifdef SYS_sched_getaffinity
  case SYS_sched_getaffinity:
#endif
#ifdef SYS_sched_getattr
  case SYS_sched_getattr:
#endif
#ifdef SYS_sched_getparam
  case SYS_sched_getparam:
#endif
#ifdef SYS_sched_get_priority_max
  case SYS_sched_get_priority_max:
#endif
#ifdef SYS_sched_get_priority_min
  case SYS_sched_get_priority_min:
#endif
#ifdef SYS_sched_getscheduler
  case SYS_sched_getscheduler:
#endif
#ifdef SYS_sched_rr_get_interval
  case SYS_sched_rr_get_interval:
#endif
#ifdef SYS_sched_setaffinity
  case SYS_sched_setaffinity:
#endif
#ifdef SYS_sched_setattr
  case SYS_sched_setattr:
#endif
#ifdef SYS_sched_setparam
  case SYS_sched_setparam:
#endif
#ifdef SYS_sched_setscheduler
  case SYS_sched_setscheduler:
#endif
#ifdef SYS_sched_yield
  case SYS_sched_yield:
#endif
#ifdef SYS_select
  case SYS_select:
#endif
#ifdef SYS_setfsgid
  case SYS_setfsgid:
#endif
#ifdef SYS_setfsgid32
  case SYS_setfsgid32:
#endif
#ifdef SYS_setfsuid
  case SYS_setfsuid:
#endif
#ifdef SYS_setfsuid32
  case SYS_setfsuid32:
#endif
#ifdef SYS_setgid
  case SYS_setgid:
#endif
#ifdef SYS_setgid32
  case SYS_setgid32:
#endif
#ifdef SYS_setgroups
  case SYS_setgroups:
#endif
#ifdef SYS_setgroups32
  case SYS_setgroups32:
#endif
#ifdef SYS_setitimer
  case SYS_setitimer:
#endif
#ifdef SYS_setns
  case SYS_setns:
#endif
#ifdef SYS_setpgid
  case SYS_setpgid:
#endif
#ifdef SYS_setpriority
  case SYS_setpriority:
#endif
#ifdef SYS_setregid
  case SYS_setregid:
#endif
#ifdef SYS_setregid32
  case SYS_setregid32:
#endif
#ifdef SYS_setresgid
  case SYS_setresgid:
#endif
#ifdef SYS_setresgid32
  case SYS_setresgid32:
#endif
#ifdef SYS_setresuid
  case SYS_setresuid:
#endif
#ifdef SYS_setresuid32
  case SYS_setresuid32:
#endif
#ifdef SYS_setreuid
  case SYS_setreuid:
#endif
#ifdef SYS_setreuid32
  case SYS_setreuid32:
#endif
#ifdef SYS_setrlimit
  case SYS_setrlimit:
#endif
#ifdef SYS_set_robust_list
  case SYS_set_robust_list:
#endif
#ifdef SYS_setsid
  case SYS_setsid:
#endif
#ifdef SYS_set_thread_area
  case SYS_set_thread_area:
#endif
#ifdef SYS_set_tid_address
  case SYS_set_tid_address:
#endif
#ifdef SYS_setuid
  case SYS_setuid:
#endif
#ifdef SYS_setuid32
  case SYS_setuid32:
#endif
#ifdef SYS_sigaction
  case SYS_sigaction:
#endif
#ifdef SYS_sigaltstack
  case SYS_sigaltstack:
#endif
#ifdef SYS_signal
  case SYS_signal:
#endif
#ifdef SYS_signalfd
  case SYS_signalfd:
#endif
#ifdef SYS_signalfd4
  case SYS_signalfd4:
#endif
#ifdef SYS_sigpending
  case SYS_sigpending:
#endif
#ifdef SYS_sigprocmask
  case SYS_sigprocmask:
#endif
#ifdef SYS_sigreturn
  case SYS_sigreturn:
#endif
#ifdef SYS_sigsuspend
  case SYS_sigsuspend:
#endif
#ifdef SYS_socketpair
  case SYS_socketpair:
#endif
#ifdef SYS_stat
  case SYS_stat:
#endif
#ifdef SYS_stat64
  case SYS_stat64:
#endif
#ifdef SYS_statfs
  case SYS_statfs:
#endif
#ifdef SYS_statfs64
  case SYS_statfs64:
#endif
#ifdef SYS_sysfs
  case SYS_sysfs:
#endif
#ifdef SYS_sysinfo
  case SYS_sysinfo:
#endif
#ifdef SYS_time
  case SYS_time:
#endif
#ifdef SYS_timer_create
  case SYS_timer_create:
#endif
#ifdef SYS_timer_delete
  case SYS_timer_delete:
#endif
#ifdef SYS_timerfd_create
  case SYS_timerfd_create:
#endif
#ifdef SYS_timerfd_gettime
  case SYS_timerfd_gettime:
#endif
#ifdef SYS_timerfd_settime
  case SYS_timerfd_settime:
#endif
#ifdef SYS_timer_getoverrun
  case SYS_timer_getoverrun:
#endif
#ifdef SYS_timer_gettime
  case SYS_timer_gettime:
#endif
#ifdef SYS_timer_settime
  case SYS_timer_settime:
#endif
#ifdef SYS_times
  case SYS_times:
#endif
#ifdef SYS_ugetrlimit
  case SYS_ugetrlimit:
#endif
#ifdef SYS_ulimit
  case SYS_ulimit:
#endif
#ifdef SYS_umask
  case SYS_umask:
#endif
#ifdef SYS_uname
  case SYS_uname:
#endif
#ifdef SYS_unshare
  case SYS_unshare:
#endif
#ifdef SYS_uselib
  case SYS_uselib:
#endif
#ifdef SYS_ustat
  case SYS_ustat:
#endif
#ifdef SYS_wait4
  case SYS_wait4:
#endif
#ifdef SYS_waitid
  case SYS_waitid:
#endif
#ifdef SYS_waitpid
  case SYS_waitpid:
#endif
    return deny_all;

#ifdef SYS_exit
  case SYS_exit:
#endif
#ifdef SYS_exit_group
  case SYS_exit_group:
#endif
    /* Special case: exiting is allowed, even in -e mode,
       but the exit status is forced to 0. */
    SET_REG(pid, ARG1, 0);
    return 0;

#ifdef SYS_fcntl
  case SYS_fcntl:
#endif
#ifdef SYS_fcntl64
  case SYS_fcntl64:
#endif
    /* Special case: fcntl is allowed, but only for the *FD and *FL
       operations.  This is a compromise between not allowing it at
       all, which would break some interpreters, and trying to go
       through the dozens of extended ops and figure out which ones
       can affect global state.  */
    {
      int cmd = GET_REG(pid, ARG2);
      if (cmd == F_DUPFD || cmd == F_DUPFD_CLOEXEC ||
          cmd == F_GETFD || cmd == F_SETFD || cmd == F_SETFL || cmd == F_GETFL)
        return deny_all;
    }
    return 1;

#ifdef SYS_kill
  case SYS_kill:
#endif
#ifdef SYS_rt_sigqueueinfo
  case SYS_rt_sigqueueinfo:
#endif
#ifdef SYS_rt_tgsigqueueinfo
  case SYS_rt_tgsigqueueinfo:
#endif
#ifdef SYS_tkill
  case SYS_tkill:
#endif
#ifdef SYS_tgkill
  case SYS_tgkill:
#endif
    /* Special case: kill is allowed if and only if directed to the calling
       process. */
    {
      pid_t kpid = GET_REG(pid, ARG1);
      if (kpid == pid)
        return deny_all;
    }
    return 1;

#ifdef SYS_mmap
  case SYS_mmap:
#endif
#ifdef SYS_mmap2
  case SYS_mmap2:
#endif
    /* Special case: mmap is allowed if it is private or read-only.  */
    {
      int prot  = GET_REG(pid, ARG3);
      int flags = GET_REG(pid, ARG4);
      if ((flags & (MAP_SHARED|MAP_PRIVATE)) == MAP_PRIVATE)
        return deny_all;
      if (!(prot & PROT_WRITE))
        return deny_all;
    }
    return 1;

    /* Special case: open() variants are allowed only if read-only and
       not creating. */
#ifdef SYS_open
  case SYS_open:
#endif
#ifdef SYS_openat
  case SYS_openat:
#endif
#ifdef SYS_open_by_handle_at
  case SYS_open_by_handle_at:
#endif
    {
      int flags = ((scnum == SYS_open)
                   ? GET_REG(pid, ARG2)
                   : GET_REG(pid, ARG3));
      if (!(flags & O_CREAT) && ((flags & O_ACCMODE) == O_RDONLY))
        return deny_all;
    }
    return 1;

#ifdef SYS_write
  case SYS_write:
#endif
#ifdef SYS_write64
  case SYS_write64:
#endif
#ifdef SYS_writev
  case SYS_writev:
#endif
#ifdef SYS_pwrite
  case SYS_pwrite:
#endif
#ifdef SYS_pwrite64
  case SYS_pwrite64:
#endif
#ifdef SYS_pwritev
  case SYS_pwritev:
#endif
    /* Special case: optionally, the program is allowed to write to
       stderr.  This opens a gaping hole in the policy, but it can be
       quite entertaining to watch programs moan about how nothing works. */
    if (allow_stderr) {
      int fd = GET_REG(pid, ARG1);
      if (fd == 2)
        return 0;
    }
    return 1;

  default:
    /* All other system calls are unconditionally denied. */
    return 1;
  }
}

static void
usage(char *progname)
{
  fprintf(stderr, "usage: %s [-adeS] program args...\n", progname);
  fputs("\t-a  log allowed system calls\n"
        "\t-d  log denied system calls\n"
        "\t-e  deny everything, not just output\n"
        "\t-S  permit writes to stderr\n", stderr);
  exit(2);
}

int
main(int argc, char **argv)
{
  pid_t pid;
  int   status;
  int   opt;
  long  last_syscall = SYS_unimplemented;
  int   last_allowed = 0;
  int   after_execve = 0;
  int   trace_active = 0;
  int   allow_stderr = 0;
  int   deny_all     = 0;
  int   log_allowed  = 0;
  int   log_denied   = 0;

  while ((opt = getopt(argc, argv, "+adeS")) != -1) {
    switch (opt) {
    case 'a': log_allowed  = 1; break;
    case 'd': log_denied   = 1; break;
    case 'e': deny_all     = 1; break;
    case 'S': allow_stderr = 1; break;
    default:
      usage(argv[0]);
    }
  }
  if (optind == argc) {
    usage(argv[0]);
  }

  setvbuf(stdout, 0, _IOLBF, 0);
  setvbuf(stderr, 0, _IOLBF, 0);

  pid = fork();
  if (pid == -1) {
    perror("fork");
    exit(1);

  } else if (pid == 0) {
    raise(SIGSTOP); /* synch with parent */
    execvp(argv[optind], argv+optind);
    perror("execvp");
    exit(1);
  }

  /* If we get here, we are the parent. */
  for (;;) {
    pid_t rv = waitpid(pid, &status, WUNTRACED);
    if (rv != pid) {
      perror("waitpid");
      kill(pid, SIGKILL);
      exit(1);
    }
    if (!WIFSTOPPED(status)) {
      if (WIFEXITED(status))
        printf("Program exited, status = %d\n", WEXITSTATUS(status));
      else if (WIFSIGNALED(status))
        printf("Program killed by signal %d\n", WTERMSIG(status));
      else {
        printf("Un-decodable status %04x\n", status);
        kill(pid, SIGKILL); /* just in case */
      }
      exit(0);
    }
    if (WSTOPSIG(status) == SIGSTOP && !trace_active) {
      /* This is the raise(SIGSTOP) on the child side of the fork. */
      trace_active = 1;
      xptrace(PTRACE_SEIZE, pid, 0, (void*)PTRACE_O_TRACESYSGOOD);
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    }
    else if (WSTOPSIG(status) == (SIGTRAP|0x80)) {
      if (last_syscall == SYS_unimplemented) {
        last_syscall = GET_REG(pid, NUMBER);
        /* The child process is allowed to execute normally until an
           execve() succeeds.  */
        if (after_execve && deny_syscall(pid, last_syscall,
                                         deny_all, allow_stderr)) {
          last_allowed = 0;
          SET_REG(pid, NUMBER, SYS_unimplemented);
        } else {
          last_allowed = 1;
          if (log_allowed) {
            /* Log this now, we may not get another chance. */
            printf("syscall %ld...\n", last_syscall);
          }
        }
      } else {
        if (last_allowed ? log_allowed : log_denied) {
          long scret = GET_REG(pid, RESULT);
          printf("syscall %ld%s = %ld\n",
                 last_syscall, last_allowed ? "" : " (denied)", scret);
        }
        if (last_allowed && (last_syscall == SYS_execve ||
                             last_syscall == SYS_execveat)) {
          long scret = GET_REG(pid, RESULT);
          if (scret == 0)
            after_execve = 1;
        }
        last_syscall = SYS_unimplemented;
      }
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    }
    else if (WSTOPSIG(status) == SIGTRAP) {
      /* Swallow all SIGTRAPs, they are probably spurious debug events. */
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    } else {
      /* Allow all normal signals to proceed unmolested. */
      if (log_allowed) {
        printf("process received signal %d\n", WSTOPSIG(status));
      }
      xptrace(PTRACE_SYSCALL, pid, 0, (void*)(uintptr_t)WSTOPSIG(status));
    }
  }
}
zwol
quelle
1
"Das Ziel kann seine Befehlszeilenargumente lesen, reine Berechnungen ausführen und einen 8-Bit-Exit-Status erzeugen, aber keinen Speicher zuweisen oder E / A ausführen." - Ich weiß nicht, ob Sie die vier Kriterien noch erfüllen . Ganzzahlen können aus Befehlszeilenargumenten interpretiert werden. Der Exit-Status kann für eine einfache Ausgabe genutzt werden. Zugabe wird nicht behindert; und alles, was Sie für einen Primalitätstest benötigen, ist die Fähigkeit, reine Berechnungen durchzuführen, ein bisschen Stapelspeicher und eine Schleife.
Blacklight Shining
1
@BlacklightShining Ich denke, dass dies eine so große Einschränkung im Vergleich zu normalem Verhalten darstellt, dass es akzeptabel sein sollte, obwohl Sie, wie Sie sagen, immer noch einen Primetester schreiben könnten, aber der -DNO_EXITModus ist für Leute, die sich so fühlen wie Sie. In diesem Modus ist keine sinnvolle Ausgabe möglich.
21.
1
@BlacklightShining Ich habe noch etwas darüber nachgedacht und das Programm im Grunde genommen von Grund auf neu geschrieben. Es ist jetzt ziemlich schlauer, was es tut, und (ich hoffe) trifft sogar die strengste Lektüre der Herausforderung.
22.
2
@Joshua Das ist klug und es wäre schwierig, diesen Ansatz zu verhindern (da das Programm nur seinen eigenen Speicher ändert), aber es ist derzeit nicht auf der Liste der "erlaubten Ausgabemethoden".
zwol
6
@JesseTG Kennen Sie sich aus strace?
zwol
30

TeX

\catcode`\\=10

Ich bin mir nicht sicher, ob dies tatsächlich funktionieren wird, aber theoretisch sollte dies \als Escape-Charakter abbrechen , sodass Sie keine Möglichkeit haben, es zu beheben. Normalerweise kann TeX Dateien lesen und schreiben, jetzt kann es nichts schreiben, was von der Logik abhängt. Somit ist die Sprache nun wie von OP definiert defekt.

BEARBEITEN: Andere Kill-Befehle aus den Kommentaren (obwohl beide möglicherweise gegen die Regel verstoßen, dass Code ausgeführt werden muss):

  • \def\fi{}\iffalseby smpl erzeugt einen nicht verschließbaren if-Zweig
  • \catcode13=9%von iwillnotexist idonotexist erstellt einen unendlichen Kommentar
Kopffüßer
quelle
3
Eine bessere Version: \def\fi{}\iffalse. Ich kann keine Antworten dazu posten, da dies mindestens 10 Wiederholungen von dieser Site erfordert, aber dies wird auch keine Ausgabe mehr ermöglichen.
user530873
1
@smpl du kannst immer noch \fizu seiner ursprünglichen Bedeutung zurückfinden , oder? Somit ist die Sprache nicht irreparabel gebrochen.
Kopffüßer
1
@ Kopffüßer \fiist ein TeX-Primitiv. Und nein, Sie können an dieser Stelle nichts neu definieren, \iffalsewurde angerufen.
user530873
1
@smpl Hmm, ich verstehe. Sehr schlau.
Kopffüßer
1
+1. Ich habe gerade angefangen, mich aus dem TeXBook herauszubilden, und als mir klar wurde, \catcode13=9%dass die Sprache völlig kaputt gehen würde (alles, was danach %steht, wird kommentiert und Zeilenumbrüche (ASCII-Zeichen 13) werden ignoriert, sodass der Kommentar unendlich lang ist), wollte ich ihn hier posten. Aber Sie haben hier schon einen etwas längeren Befehl.
Ich werde nicht existieren Idonotexist
29

Kratzen

Arbeitsbild unterbrechen
Die when [timer v] > (0)wird ausgeführt, sobald der Code initialisiert wurde. Wenn Sie sich im Editor befinden, ist dies noch nicht einmal der Fall, bevor Sie den Code starten. Das when I receive (join[][])führt dazu , dass ein Fehler jedes Mal etwas geworfen wird ausgestrahlt wird, pausiert die Ausführung von Code , wenn Sie Entwickler - Version von Flash haben. Die breakFunktion erstellt Klone und löst den Broadcast-Fehler aus. Jeder einzelne Klon dauert zwei Sekunden, löscht sich dann von selbst und belastet den Stapel. Und jeder Klon reagiert auf das when [timer v] > (0)Ausführen der breakSubroutine und das Zurücksetzen des Timers, wodurch der Timer-Code erneut ausgeführt wird. Außerdem reagiert jeder Klon auch auf jeden Broadcast-Fehler, dh die Anzahl der Fehler pro Auswertung breakist die Anzahl der Klone im Quadrat. Habe ich vergessen zu erwähnen, dass die breakFunktion hatrun without screen refreshüberprüft, was dazu führt, dass der Editor einfriert, ruckelt und verzögert sowie Speicher abruft und zuweist. Und die CPU voll ausschöpfen.

Jeder Code, der bei dieser Ausführung irgendwo hinzugefügt wird, kann keine Klone erstellen (Limit von 300 Klonen überschritten) sowie den Computer, auf dem er ausgeführt wird, aufheizen und abstürzen. Und Speicher abrufen, bis kein Speicher mehr verfügbar ist, sodass die Variablen sich nicht mehr richtig verhalten.

Und when [timer v] > (0)wenn es zu viel Verzögerung gibt, um den Block auszulösen , läuft er weiter break.

Vielen Dank an @towerofnix, der mich an die Panne erinnert hat, die when I receiveich vor einiger Zeit gefunden habe, und der mir die Idee für gegeben hat run without screen refresh. Wenn Ihnen das gefallen hat, finden Sie hier das Original: https://codegolf.stackexchange.com/a/61357/43394

wizzwizz4
quelle
+1 Es könnte auch Spaß machen, einen atomaren (ohne Bildschirmaktualisierung ausgeführten) Block mit dem folgenden stop this script
Code
Wie funktioniert diese " when I receivePanne"?
Scimonster
@Scimonster Der Hatblock when I receivedient nur zur Eingabe aus der Dropdown-Liste. Der join[][]Block gibt einen Datentyp zurück, den der when I recieveBlock nicht akzeptieren soll. Jedes Mal, wenn etwas gesendet wird, überprüfen und bewerten alle Hutblöcke den Rückgabewert des Blocks und lösen einen incorrect typeFehler aus.
wizzwizz4
Aha. Sie müssen jedoch die JSON-Datei hacken, um den joinBlock tatsächlich dort hineinzuholen .
Scimonster
1
@ppperry Es basiert auf einer Flash - Version abhängig ist , die Fehler ignoriert - dies nicht existieren. Auf das Äußerste gebracht, könnte "für klein genug n" verwendet werden, um zu sagen, (n-1)funktioniert für positiv n<3, aber da dies algorithmisch ist, sollte ein guter Algorithmus in der Lage sein, ngroß genug zu machen , um dieses Argument abschütteln zu können. Ich bin mir nicht sicher, ob eine schnellere oder langsamere Maschine sie benutzerfreundlicher machen würde. Ich bin jedoch damit einverstanden, dass diese Lösung umgangen werden kann. Es ist kein Bullen-und-Räuber , aber trotzdem gut gemacht.
wizzwizz4
27

Mathematica / Wolfram-Sprache

Mathematica ist eine interpretierte Sprache, in der Befehlsnamen Symbole sind, die vom Programmierer bearbeitet werden können. Sie können integrierte Operatoren nicht löschen, sie jedoch überladen oder auf andere Weise ihre Funktion ändern. Das Folgende verschlüsselt den "With" -Befehl, der für die Zuweisung zu Variablen auch intern benötigt wird. Diese Änderung verhindert, dass der Kernel Argumente enthält, die nicht ausgewertet wurden, bis die Zuweisung abgeschlossen ist, und bringt die Sprache zum Erliegen.

ClearAttributes["With", HoldAll]

Wenn dieser Befehl in einer interaktiven Sitzung oder in einem Codeblock ausgeführt wird, kann Mathematica nicht einmal hinzufügen 1+1(die resultierende Fehlermeldung ist etwa eine Seite lang, sodass ich sie hier nicht einfügen werde ).

Michael Stern
quelle
26

PHP

Ich bin überrascht, dass es tatsächlich funktioniert, aber das Schließen STDOUTund STDERRUnterdrücken aller Ausgaben. Um sicherzustellen, dass sie nicht erneut geöffnet werden, öffnen wir /dev/nulldrei Mal, um die Dateideskriptoren 0, 1 und 2 neu zuzuweisen:

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

// insert program here

Mehr dazu: https://stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

Fabian Schmengler
quelle
Es gibt andere gültige Ausgabeformulare, einschließlich des Schreibens in Dateien und der Verwendung des Exit-Codes des Programms. Siehe den Link im entsprechenden Punkt der Spezifikation.
Martin Ender
1
Was genau erlaubt ist und was nicht, war mir nicht klar. Im Tag-Wiki habe ich zum Beispiel nichts über Dateien und Exit-Codes gefunden. Aber wenn sie erlaubt sind, denke ich nicht, dass ich dies in eine gültige Vorlage verwandeln kann.
Fabian Schmengler
Die Frage wurde so bearbeitet, dass nur ein Ausgabeformular deaktiviert werden kann.
Jimmy23013
20
@ Jimmy23013 was? Das macht den Punkt der Frage völlig zunichte.
Hobbs
5
@ jimmy23013 Wenn es gültig ist, nur eine Ausgabeform zu deaktivieren, muss ich zum Beispiel nur den Exit-Code des Programms (wie von Martin vorgeschlagen) unterdrücken, obwohl die Sprache ohne Exit-Code vollständig verwendbar ist.
Jerry Jeremiah
24

DOS Batch (vor Windows 95 glaube ich)

CTTY

Ohne Argumente wird die Befehlszeile vom Terminal getrennt. Weitere Versuche, Eingaben zu lesen oder Ausgaben zu generieren, führen zu keinem Ergebnis.

Wenn Sie wissen möchten, wie Sie CTTY richtig verwenden:

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

Eine etwas leistungsstärkere Batch-Datei könnte sogar den Anrufbeantworter des Modems ansprechen und eine Verbindung zu CTTY herstellen.

Joshua
quelle
23

Common Lisp

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

Ich hoffe, Sie haben diese öffnenden Klammern nicht gebraucht.

Dies ist ein Reader-Makro, das den Lisp Reader anweist, jede Instanz von (durch einen Aufruf von zu ersetzen (lambda (x y) ()), einer Funktion, die zwei Argumente akzeptiert und nichts zurückgibt. So würde es zum Beispiel (foo)als gelesen foo), fooals Variable interpretiert und dann einen nicht übereinstimmenden Klammerfehler auf werfen 0.

Kerzen
quelle
2
Bitte auch )als etwas kaputt interpretieren ! Auf diese Weise treten weniger Fehler auf.
Wizzwizz4
7
Ich liebe es. "Worauf verlässt sich lisp? Ein einziger Charakter? Es wäre eine Schande, wenn etwas ... passiert wäre ..." Es ist die gleiche Logik wie die Neudefinition von "\" in TeX.
Felixphew
23

Kratzen

Hier ist ein ziemlich einfaches Beispiel, das Ihren Browser (und theoretisch Ihren Computer) zum Absturz bringt:

Sofortiger Absturz

Ich ließ dies etwa zwanzig Sekunden laufen und verlor dann 2,65 GB Speicher an Scratch. Nur einen Moment später und 5 GB waren weg.

Ich schlage vor, Sie haben die Möglichkeit, Adobe Flash oder Ihren Webbrowser zu beenden, bevor Sie dies ausführen!


Ich wollte wirklich eine coole Antwort wie die von clear(this)JS geben, aber leider hat Scratch keine Möglichkeit, dies zu tun. Fühlen Sie sich frei, diesen Beitrag zu aktualisieren (oder Ihren eigenen zu erstellen), wenn Sie einen anderen Weg finden, Scratch unbrauchbar zu machen!

Florrie
quelle
2
Wo fügen Sie den Benutzercode hinzu, und wird er tatsächlich ausgeführt?
Jimmy23013
Benutzercode? Überall im Projekt, solange dieses Snippet eingefügt wird. Es wird einmal 0,3 Sekunden nach der ersten Ausführung und dann alle 0,3 Sekunden ausgeführt (mit der Ausnahme, dass ein Skript ohne Ende wiederholt wird, wodurch Scratch sehr langsam wird). Ist es in Ordnung, wenn ich diesen Beitrag mit einem besseren, leistungsfähigeren Crasher aktualisiere?
Florrie
5
Jemand, der Scratch benutzt ... d: -D YAY !!!
wizzwizz4
@towerofnix Übrigens, ich habe das hier verbessert / radikal modifiziert / neu erstellt: codegolf.stackexchange.com/a/61490/43394 Meiner ist nicht darauf angewiesen, dass das Mikrofon eingeschaltet ist.
wizzwizz4
1
@ wizzwizz4 Ja, deine ist viel besser als meine. Bitte wählen Sie seine
Florrie
20

Thue

::=

Mit einem Zeilenumbruch am Ende

Die Sprache basiert auf der Definition von Regelsätzen und a ::=kennzeichnet das Ende des Regelsatzes. Es ist unmöglich, in Thue ALLES zu tun, ohne Regeln zu definieren, die dies tun. Unabhängig davon, was Sie nach dem ::=tun, kann also nichts passieren.

Alternative Antwort

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

(usw. für alle Zeichen in Unicode, einschließlich der AZeichen vor dem Zeichen und nicht druckbarer Zeichen). Dies erfordert die Befehlszeilenoption -r.

Pfeffer
quelle
Ich denke, der Text ist nicht grammatikalisch das Gleiche wie etwas, das die Kriterien erfüllt (wie ein Regelsatz).
Jimmy23013
16

MATLAB

Der folgende Code macht die Umgebung vollständig unbrauchbar 1 :

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

Dadurch werden die builtinFunktion und die clearFunktion mit neuen anonymen Funktionshandles überschrieben, die bei falsejedem Versuch, diese Funktionen aufzurufen , einfach zurückgegeben werden. Die builtinFunktion stellt sicher , dass , wenn es alle benutzerdefinierten Funktionen , die Sie in MATLAB schreiben , die den gleichen Namen wie diejenigen sind , die in MATLAB-in gebaut werden (Dinge wie sum, max, minusw.), Sie sind in der Lage diese eindeutig anstelle der überladenen Funktionen aufrufen . Ebenso haben clearSie die Möglichkeit, alle derzeit deklarierten Variablen zu löschen, damit Sie neu beginnen können. Wenn Sie diese Funktionen entfernen, können Sie MATLAB nur dann verwenden, wenn Sie das Programm neu starten.

In MATLAB R2015a erhalte ich außerdem die folgende Meldung:

Bildbeschreibung hier eingeben

Der Arbeitsbereich sind die Variablen, die derzeit in der Umgebung deklariert sind, damit Sie sie später verwenden können. Dadurch wird der Arbeitsbereich dauerhaft deaktiviert, sodass alle Variablen, die Sie erstellen, nicht gespeichert werden und daher bei der Ausführung von Codezeilen in MATLAB keine Fortschritte erzielt werden können.

1: Gutschrift geht an den Benutzer Dev-iL , der die Idee ursprünglich entdeckt hat.

rayryeng
quelle
2
In R2014b können Sie dies feval('clear')beheben. Oder: s=str2func('clear'); s().
Stewie Griffin
13

///

/\///

Der einzige Betrieb in /// ist String - Ersetzung wiederholt, wie folgt aus : /pattern/replacement/.

Dieser Code entfernt alle Zeichen /, auf diese Weise können Sie keine wiederholten Zeichenfolgenersetzungen verwenden, sodass im Grunde alles, was Sie danach schreiben, gedruckt wird (mit Ausnahme von /s).

Sie können \s immer noch verwenden , aber das hilft Ihnen nicht viel.

Akrolith
quelle
Ich habe mich immer gefragt, ob es möglich ist, einen Teil /// des Codes zu schreiben, der garantiert alles nach sich selbst löscht und damit anhält, ohne etwas zu drucken. Es scheint unmöglich, aber ich habe nicht an einen Beweis gedacht, dass es unmöglich ist.
Tanner Swett
12

Befunge-96

'~h

Der Code des Benutzers kann nach dieser Sequenz an einer beliebigen Stelle folgen, sofern dies die ersten drei Zeichen in der Quelle sind.

Der 'Befehl (One-Shot-String-Modus) schiebt den ASCII-Wert von ~auf den Stapel (dh 126), und der hBefehl setzt dann das so genannte holistische Delta mit diesem Wert. Für diejenigen, die nicht mit Befunge-96 vertraut sind, ist das Holistische Delta ein Offset, der zum Wert jedes Befehlsbytes addiert wird, auf das der Interpreter stößt.

Sobald das Delta auf 126 gesetzt ist, kann nur ein gültiger Befehl ~(Zeicheneingabe) über ein Null-Byte in der Quelle generiert werden . Alles andere als ein Null-Byte würde in einen Wert größer als 126 übersetzt, und keiner dieser Werte wäre ein gültiger Befunge-Befehl.

Ich denke, man kann mit Sicherheit sagen, dass dies die Qualifikation als Programmiersprache unmöglich machen würde.

James Holderness
quelle
11

Boo

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

Und dann, woanders im Projekt,

harmless

Ein einfaches Makro mit einem harmlos klingenden Namen, aber einem erstaunlich frustrierenden Effekt. Der Boo-Compiler verwendet eine mehrstufige Pipeline, die mit dem Parsen der Quelle in einen AST beginnt und mit der Codegenerierung endet. (Im Allgemeinen. Es kann für verschiedene Anwendungen neu konfiguriert werden.) In jedem Schritt dazwischen werden verschiedene Operationen auf dem AST ausgeführt.

Teilweise erfolgt die Makroerweiterung, in der Makros im Kontext des Compilers ausgeführt werden. Erinnern Sie sich an das Bit im letzten Absatz, dass die Pipeline umkonfigurierbar ist? Wenn Sie während der Makroerweiterung ein Makro aufrufen, das die Pipeline löscht, wird dem Benutzer kein Fehler angezeigt, aber alle Schritte nach der Makroerweiterung (einschließlich der Codegenerierung) sind nicht mehr vorhanden. Sie erhalten also etwas, das wie eine erfolgreiche Kompilierung aussieht - es werden keine Fehlermeldungen angezeigt -, aber aus irgendeinem Grund wird keine Binärdatei erstellt! Wenn Sie das Makro und den Aufruf gut verbergen, fahren Sie garantiert auch die besten Problemlöser die Wand hoch.

Mason Wheeler
quelle
Diese Antwort ist ungültig, da der Benutzercode niemals ausgeführt wird.
pppery
@ppperry: Sicher ist das so: Das Makro kann als Teil des Benutzercodes geschrieben und innerhalb des Compilers ausgeführt werden .
Mason Wheeler
Sie müßten für ein Zeichen des Satzes von Zeichen , wie ein Makro definieren, muss in eingegeben wird jedes einzelne Programm oder eine Reihe von Programmen, die die Kriterien boo passen machen .
pppery
@ppperry: Ja, das Aufrufen des Makros (irgendwo im Code) führt dazu, dass der Compiler abbricht und die Kriterien erfüllt. Wenn Sie versuchen, etwas Tieferes zu sagen, müssen Sie etwas klarer sein, da ich nicht sehe, wo das Problem liegt.
Mason Wheeler
2
@slebetman: Und wenn Sie eine REPL oder Makros haben, in denen Benutzercode zur Kompilierungszeit ausgeführt wird, wird die Unterscheidung zwischen den beiden sehr unscharf.
Mason Wheeler
10

NGN / APL

NGN / APL erlaubt die Neudefinition von Primitiven, daher macht die Neudefinition ( ) aller primitiven Funktionen ("pass through": both ⊢3and 2⊢3gives 3) die Sprache völlig unbrauchbar:

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

Probieren Sie es hier aus.

Adam
quelle
1
-1 für den Moment, aber das scheint vielversprechend! Vielleicht, wenn Sie alle Primitiven neu definiert haben ...
Blacklight Shining
@BlacklightShining Los geht's.
Adám
8

Ruby (29 Zeichen)

class Object;def send;end;end

As 'send' wird intern verwendet, wenn eine Methode in Ruby aufgerufen wird, und da alle Objekte von der Object-Klasse erben. Dies sollte verhindern, dass eine Methode ausgeführt wird.

Fun Fact: Theoretisch ist das völlig in Ordnung. Aber es scheint aus irgendeinem Grund, die Ruby-Sprache nicht zu manipulieren. Ich habe keine Ahnung, warum es möglich ist, diesen Code auszuführen und trotzdem eine offene Ruby-Umgebung zu verwenden.

AJFaraday
quelle
Eigentlich funktioniert das in der Pry Ruby-Shell.
Félix Saparelli
Meinen Sie, es funktioniert wie in "das bricht es" oder es funktioniert wie in "es funktioniert immer noch danach"? Nur erwähnte ich den zweiten Fall im
normalen
1
Ich meine, es zerbricht Pry. IRB wird nicht beschädigt, und die Ausführung von .rb-Dateien wird nicht beeinträchtigt, Pry wird jedoch beschädigt.
Félix Saparelli
Interessant. Ich schätze, es gibt einen gewissen Schutz für die Sendemethode, die nicht mit PRY funktioniert.
AjFaraday
8

Tcl

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

Dadurch werden alle Keywords mit Ausnahme von ifund aus der Sprache entfernt rename.

Der obige Code würde dazu führen, dass ein neuer Code ausfällt. Es ist also fraglich, ob der neu eingefügte Code tatsächlich "ausgeführt" wird. Unten ist eine Version, die neuen Code ausführt, aber nichts tut, da alle Schlüsselwörter (außer ifund proc) in eine Nulloperation geändert werden:

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

Anstatt Schlüsselwörter zu löschen, ersetzt dieser Code sie durch eine Funktion, die nichts bewirkt.

(Hinweis: Ich verwende "Keywords" hier sehr locker, weil Tcl keine Keywords hat, sondern nur Funktionen)

Slebetman
quelle
1
Ich denke, Sie können es besser machen, indem Sie ifund renamenach der Schleife umbenennen . In der zweiten Version sollten Sie auch proceine Ausnahme machen.
Jimmy23013
@ jimmy23013 Hmm..technisch sollte man Recht haben, aber dieser Codeausschnitt funktioniert mit der aktuellen Version von tcl auch dann, wenn er procin der Liste vorher erscheint puts. Technisch sollte der Code auch ohne funktionieren, renameaber eingebaute Befehle scheinen ansonsten geschützt zu sein. Ich bin nicht sicher, was los ist, aber der Code ist getestet und funktioniert wie angekündigt.
Slebetman
@ Jimmy23013: OK. Code funktioniert jetzt ohne Aufruf rename. Es war Brainfart meinerseits - ich habe vergessen, auszuschließen proc.
Slebetman
Ich habe mich entschieden, nicht umzubenennen, ifweil es ifziemlich nutzlos ist, wenn man alleine arbeiten kann, um eine Ausgabe zu generieren.
Slebetman
Natürlich müssen Sie sie nicht umbenennen. Aber das ist kein Code-Golf. Ich dachte nur, sie könnten umbenannt werden (oder auch nicht), damit diese Antwort besser aussieht.
Jimmy23013
7

Hoon

=<  ~
(your code)

Hoon ist seltsam. Es unterscheidet sich so ziemlich von anderen Programmiersprachen, nicht nur in der Syntax, sondern auch in der Semantik. Im Gegensatz zu Sprachen wie Hexagony war es jedoch nicht absichtlich esoterisch.

Hoon kompiliert zu Nock , einer Minimal-Combinator-basierten VM. Nock ist doof: Die Spezifikation kann auf 340 Bytes komprimiert werden. Die einzige mathematische Operation ist das Inkrementieren. Alles ist ein Substantiv: ein Atom (Bignum) oder eine Zelle (Substantivpaar), wobei das gesamte Speichermodell in einem unveränderlichen azyklischen Binärbaum angeordnet ist. Die einzige Ausgabe ist das Substantiv, auf das Ihr Ausdruck reduziert ist.

Wegen des seltsamen Kompilierungsziels ist Hoon auch seltsam: Es ist völlig rein. Hoon kompiliert bis zu einem Nock-Ausdruck, der in einem "Kontext" ausgewertet wird. Der gesamte Kernel und die stdlib sowie alle Variablen werden vom Kontext implizit an das Programm übergeben.

Um Hoon unbrauchbar zu machen, verwenden wir einfach =<"a im Kontext von b auswerten". Wir werten immer aus ~, was null ist. Egal was bpassiert, es kann den Wert nicht ändern, auf den es reduziert wird, und da es keine Nebenwirkungen hat, kann es keine Ein- oder Ausgabe machen.

Randnotiz: Da Sie keine Eingabeaufforderung von Hoon (Reinheit!) Erhalten können, handelt es sich nach den Regeln eigentlich nicht um eine Programmiersprache. Die Eingabe erfolgt über Funktionsargumente, die Ausgabe über Rückgabewerte (oder ~&, was eher eine Funktion zur Fehlersuche in printf ist und für das Programm transparent ist).

Damit ein Programm Eingaben in Urbit erhält, schreiben Sie tatsächlich ein Programm, das eine Funktion zurückgibt, die Eingaben akzeptiert, und die Shell fragt in Ihrem Namen und übergibt sie an den Rückruf.

RenderSettings
quelle
3
Auf jeden Fall eine Programmiersprache nach unseren Maßstäben
cat
7

Taxi, 2354 Bytes.

Dieses kleine Programm fährt einfach das Taxi in einer großen Spritztour durch Townsburg, ohne Benzin. Jeder Code, den Sie danach ausführen, führt schnell zu Fehlern error: out of gas. Und selbst wenn Sie eine Tankstelle erreichen könnten, die ich nicht für möglich halte, könnten Sie kein Benzin bekommen, da kein Geld gesammelt wurde, da es keine Passagiere gibt.

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.
Pfeffer
quelle
6

JavaScript im Browser

Zumindest im IE11.

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

Deaktiviert das Schreiben in das Dokument, das Schreiben in die globale Variable und die Rückkehr von der Funktion.

Kommentar, wenn ich eine Ausgabemethode verpasst habe!

wizzwizz4
quelle
Ausnahmen werden weiterhin in der Konsole angezeigt. Sie können damit umgehen, indem Siewindow.addEventListener('error',function(){});
Ismael Miguel
@IsmaelMiguel Jetzt kann ich nicht den ganzen Kredit nehmen! d ;-D
wizzwizz4
4
Funktioniert das ernsthaft? Das macht überhaupt keinen Sinn: documentsollte im eingefügten Code weiterhin über den äußeren Bereich zugänglich sein und erst ersetzt werden, nachdem der eingefügte Code ausgeführt wurde.
Peter Taylor
@PeterTaylor :-( Deine Logik hat meine Theorie gebrochen.
wizzwizz4
2
Es ist nicht einfach
Peter Taylor
6

Python 2, wahnsinnig groß

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

Diese wahnsinnig große Menge an Code ist eine Wiederbelebung des alten rexecModuls (in Python 2.3 aufgegeben) mit einer Reihe neuer Module, die der "ok" -Liste hinzugefügt wurden, und einer Reihe behobener Schwächen (einschließlich der object.__subclasses__()Methode, mit der mindestens zwei andere Pythons erstellt wurden) Antworten ungültig).

Ein Großteil dieses Codes (die __init__Methode der RExecKlasse und der gesamten ModuleImporterKlasse) wird mit kleinen Änderungen aus der Python-Standardbibliothek kopiert.

Pfeffer
quelle
2
0.o wh ... was hast du getan
Katze
8064 bytesübrigens
Katze
@cat nicht, dass dies Code Golf ist. Ich könnte wahrscheinlich mindestens 1000 Bytes Golf spielen.
Paprika
Natürlich, aber du
Katze