Intente escribir un código en su lenguaje y haga que ya no satisfaga nuestros criterios de ser un lenguaje de programación .

Un lenguaje satisface nuestros criterios (versión simplificada para este desafío) de ser un lenguaje de programación si:

• Puede leer la entrada del usuario que representa tuplas de enteros positivos de alguna manera.
• Puede generar al menos dos resultados posibles diferentes según la entrada.
• Puede tomar dos enteros positivos y agregarlos (y el resultado puede afectar la salida).
• Puede tomar un número entero positivo y decidir si es primo (y el resultado puede afectar la salida).
• Para el propósito de este desafío, se ignora cualquier tipo de salida que no sea un método de salida permitido para un desafío normal . Por lo tanto, no importa si el programa también puede reproducir una pieza musical, o publicar a través de HTTP, etc.
• Actualización: también puede elegir uno o algunos de los métodos de salida permitidos e ignorar todos los demás. Pero debe usar la misma definición en todas partes en los siguientes criterios. Y si su programa puede deshabilitar más de un método de salida, eso merece más votos a favor.

Ejemplos como hacer que no pueda salir, o deshabilitar todas las construcciones de bucle para que no pueda hacer una prueba de primalidad y asegurarse de que el usuario no pueda volver a habilitarlas.

Debe dejar un lugar para insertar un nuevo código. Por defecto, está al final de su código. Si consideramos poner el código fuente en ese lugar en su respuesta y ejecutar el código completo como un programa completo, el intérprete de un nuevo idioma, ese idioma no debería satisfacer los criterios.

Pero el código insertado debe ejecutarse de tal manera que un lenguaje que satisfaga los criterios:

• El código insertado debe ser gramaticalmente igual que algo (digamos que es un bloque de código en los siguientes criterios) que generalmente satisfacen los criterios, desde la perspectiva de quien quiera escribir un resaltador de sintaxis. Por lo tanto, no puede estar en una cadena, comentario, etc.
• El código insertado debe ejecutarse realmente, de una manera que se supone que satisface los criterios. Por lo tanto, no puede estar en una función no utilizada o sizeofen C, no puede ejecutar solo una parte no funcional en el código, y no puede colocarla después de un bucle infinito, etc.
• No puede limitar el número de posibles programas gramaticalmente correctos generados de esta manera. Si ya hay algo así como un límite de longitud en el idioma que está utilizando, no debería satisfacer los criterios, incluso si se elimina este límite.
• No puede modificar o "usar" el contenido de entrada / salida, pero puede evitar que se acceda a ellos.
• Estos criterios generalmente solo se aplican a idiomas sin E / S explícitas:
  • Su código debe redirigir la entrada del usuario (que contiene información de longitud arbitraria) al código insertado, si un bloque de código generalmente no puede obtener la entrada del usuario directa / explícitamente en el idioma que está utilizando.
  • Su código debe imprimir el valor devuelto del código insertado, si un bloque de código generalmente no puede generar cosas directamente / explícitamente en el idioma que está utilizando.
  • En caso de que imprima el valor devuelto y esté escrito en el idioma que está utilizando, el tipo devuelto debería poder tener 2 valores prácticamente posibles diferentes. Por ejemplo, no puede usar el tipo struct {}o struct {private:int x;}en C ++.

Este es un concurso de popularidad. La respuesta válida más votada (para que nadie haya detectado un error o se hayan solucionado todos los errores) gana.

Aclaraciones

• No debe modificar el código en forma de texto, pero puede cambiar la sintaxis antes de interpretar o compilar el código.
• Puede hacer otras cosas mientras se ejecuta el código. Pero la razón por la que no cumple con los criterios debería estar dentro del código insertado. Puede producirse un error debido a la interferencia de otro hilo, pero no solo ser eliminado por otro hilo.
• Básicamente, todas las especificaciones significan que debería ser gramaticalmente probable que satisfaga los criterios si no se modificaron todas las funciones incorporadas, pero en realidad no lo hacen. Está bien si encuentra soluciones alternativas no gramaticales, como pasar los parámetros al bloque de código correctamente, pero hacer que no puedan usarse de alguna manera.
• Nuevamente, el código insertado debe ejecutarse realmente. El código después de un bucle infinito o bloqueo se considera "no ejecutado realmente", por lo tanto, no es válido . Esas respuestas pueden ser interesantes, pero ya hay otras preguntas de bucle infinito o fallas en este sitio, y puede encontrar una más adecuada para responder. Si no, considere hacer una nueva pregunta. Ejemplos de esas preguntas son:
  • El bucle infinito más corto que no produce salida
  • ¿Por qué no está terminando?
  • Bucle sin 'bucle'
  • Desafío: escriba un código que se cierre
  • Errores de tiempo de ejecución ridículos
  • Bloquea tu compilador favorito

Tabla de clasificación

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>

Shell de JavaScript

Esto hará que el lenguaje sea completamente inutilizable.

clear(this);

¿No es agradable cómo JavaScript tiene una función tan buena para autodestruirse?

Esto es bastante simple, la clearfunción vacía completamente un objeto. thisse refiere al objeto global que limpia todo, incluidos los constructores y las funciones.

Debido a que esto borra todo , hacer cualquier cosa , incluso definir un literal arrojará un error, haciendo que el lenguaje sea completamente inútil: _{* No se requiere el entorno REPL . Utiliza el motor SpiderMonkey (shell no navegador), el motor JS original.}

Emmental

;#33!

Sé que esto no es código golf, pero es la herramienta adecuada para el trabajo, ya sabes ...

El código del usuario se puede insertar después de !.

Emmental es un interesante esolang que se basa en reescribir el intérprete. Cada símbolo individual (incluidos los incorporados) se puede redefinir como un programa Emmental arbitrario. El lenguaje se basa tanto en esta característica que no proporciona ninguna construcción en bucle. En su lugar, define comandos recursivos que aparecen en sus propias definiciones.

Esta redefinición ocurre a través de !, que lee un personaje de la pila, y luego lee una cadena de la pila hasta que encuentra a ;. El carácter se redefine para que signifique el programa representado por esa cadena.

Eso quiere decir, que podemos desactivar las funciones de bucle de Emmental mediante la redefinición de ! sí mismo como el programa vacío. Si bien todos los demás códigos Emmental aún funcionan perfectamente bien, y muchos de los criterios de un lenguaje de programación aún se cumplen, es imposible redefinir más símbolos. Sin esta característica (y por lo tanto, sin poder hacer un bucle), Emmental ya no puede probar si un número es primo.

PHP

Uno puede matar completamente a PHP configurando el límite de memoria en 1.

Morirá por completo.

Prueba esto:

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

    //code here

Esto ni siquiera debería arrojar ningún error, ya que no hay suficiente memoria para eso.

Puedes leer más sobre la memory_limitdirectiva

Si el anterior no es válido, se pueden usar memorias intermedias de salida:

<?php
    ob_start();

    //code here

    ob_clear();

Esto elimina completamente cualquier salida. Dado que el búfer de salida todavía está abierto, algunas otras cosas que quedan accidentalmente después del código tampoco se mostrarán.

Usando la idea de @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();

Esto evitará el problema de eliminar el búfer de salida iniciado automáticamente, que se usa para capturar la salida a comprimir.

Esto también evita que el búfer de salida se elimine o se vacíe (se envía al navegador). Para volver a informar eso, se agrega un controlador de salida, que siempre devuelve una cadena vacía.
La ejecución ob_end_flush(); echo "Hello, world!";no producirá nada, pero enviaría la salida con un plano ob_start();.

¡Gracias a @LucasTrzesniewski por exponer este problema!

Código de máquina x86 en modo real (=> casi cualquier programa de DOS)

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

es decir

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

Espero que no estés demasiado apegado a tu mesa de interrupciones.

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

Editar: Las contramedidas están haciendo que este gigante :(

Redirige stdin y stdout a flujos nulos y reemplaza args con una matriz vacía. También utiliza enormes cantidades de trucos de reflexión para asegurarse de que el IO estándar esté realmente oculto. Finalmente, establece un administrador de seguridad para asegurarse de que el IO estándar no se pueda volver a crear y eso asegura que los programas no puedan establecer el código de salida.

Lua

_ENV=""

En Lua, _ENVes el entorno en el que se almacenan todas las variables, funciones, tablas, etc. globales. Definirlo como una cadena vacía significa que no puede definir nada nuevo, y todas las funciones y variables se borran. Esto significa que no puede generar nada, recibir entradas o prácticamente hacer nada.

Lenguaje de programación de Shakespeare

Have Fun Mr Parser.

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

Act I
Scene I The crash.

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

En SPL, el analizador incorporado que se descarga con el programa sigue reglas muy específicas sobre lo que puede suceder en el script. Una de esas reglas es que solo dos personajes pueden estar en el escenario a la vez. Además, hacer que un personaje salga del escenario que nunca estuvo en el escenario lo confundirá. Lo mismo aplica para agregar un personaje al escenario que ya está en el escenario. Cuando el analizador recibe un error, se negará a hacer NADA más; literalmente, debe cerrar completamente el programa y el analizador y luego volver a iniciar todo.

PD: si no tienes idea de cómo funciona este lenguaje, búscalo en Google. Es impresionante.

Charla

No estoy seguro si esto califica:

Smalltalk := Nil.

Esto elimina todo el entorno de tiempo de ejecución, colgando el motor de objetos. La única forma de solucionar esto es terminar por la fuerza el proceso y reiniciar desde la copia de seguridad.

Para aquellos que no saben, la forma en que funciona [Visual Works] Smalltalk es un poco extraña. Es como un mini-sistema operativo. Cuando inicia Smalltalk, carga una "imagen de memoria" en la RAM y continúa ejecutándose desde donde se quedó. Todo el IDE de Smalltalk está escrito en Smalltalk y es modificable dinámicamente.

En particular, Smalltalkes un diccionario que contiene todas las variables globales. Más particularmente, cada vez que declara una nueva clase, se crea una variable global con ese nombre, apuntando al Classobjeto para su nueva clase. Por lo tanto, establecer Smalltalken Nil(básicamente nulo) elimina todas las clases en todo el sistema. Incluso los controladores de eventos de la GUI se vuelven tontos.

No tengo idea de por qué esta variable es incluso editable. Probablemente porque es una variable global y, por lo tanto, existe como una entrada dentro de sí misma. (¿Le duele la cabeza todavía? ¿Mencioné que cada objeto tiene una clase, y las clases son objetos, por lo que cada clase tiene una clase? La clase de una clase se llama metaclase, pero una metaclase también es un objeto, que por lo tanto tiene una clase...)

Probablemente podría lograr un efecto similar al borrar el diccionario en lugar de reemplazarlo por nulo. De hecho, hay muchas cosas que puedes codificar para eliminar todas las clases en el sistema, dejándote incapaz de hacer nada. Pero dado que el compilador Smalltalk real también es una clase ... cualquier cosa que rompa el lenguaje también rompe un poco el IDE completo, así que ...

Haskell

Hay un par de posibilidades aquí.

Idea aburrida # 1: Definir mainno hacer nada. Ahora, no importa qué otro código escriba, nunca se puede ejecutar. (A menos que lo ejecute manualmente desde REPL).

Idea aburrida # 2: definir un módulo sin exportaciones públicas. Ahora, no importa qué otro código escriba, nunca se puede ejecutar.

Idea interesante: deshabilitar todas las importaciones.

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

Ahora puede definir funciones que son visibles y se pueden ejecutar ... pero no pueden hacer nada. Todos los tipos y funciones estándar de Haskell ahora están ocultos. (Con la excepción de algunas cosas realmente profundamente conectadas al lenguaje).

Más particularmente, no puede realizar ninguna E / S de ningún tipo. Tampoco puede hacer aritmética de precisión mecánica. (Dado que Int, Doubleetc., ahora no están definidos).

Sin embargo , aún puede escribir funciones de cálculo lambda que realicen algunos cálculos reales. Simplemente no puede ingresar ni sacar datos de la cosa. Pero, por supuesto, podría escribir otro módulo separado que llame al Fubarmódulo anterior y haga E / S en su nombre (lo que demuestra que el código se ejecuta y hace cosas).

Algunas sutilezas:

• La foo = foodeclaración ficticia es necesaria para evitar que alguien agregue importaciones adicionales. (Las importaciones no pueden aparecer después de las declaraciones).

• Existen varias extensiones de lenguaje Haskell no estándar que le permitirán salir de esta situación. Pero las extensiones de idioma deben activarse con un pragma compilador en la parte superior del archivo. (O con un cambio de línea de comandos al compilador. ¡Realmente no puedo evitarlo!)

Posdata

Sí, PostScript es un lenguaje de programación. Además, es un lenguaje de programación donde todas las construcciones de lenguaje son funciones definidas por el sistema, que se pueden redefinir ...

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

En inglés:

• Cree un diccionario vacío de 1,000 elementos y asígnele un nombre Magic.
• Para cada clave systemdict, agregue la misma clave a Magic, con una definición vacía (" {}").
• Empuje Magichacia la parte superior de la pila del diccionario.

A partir de este momento, cada comando de lenguaje PostScript está definido para no hacer nada. AFAIK, es imposible escapar de esta condición.

(Técnicamente, no estás "destruyendo" las definiciones antiguas, solo las estás sombreando. Si aún pudieras ejecutar end, eso saldría Magicde la pila del diccionario, eliminaría todas las órdenes y te devolvería la vida. Pero desde enden sí también está sombreado ... no hará nada ahora).

Tenga en cuenta que todos los comandos aún se ejecutarán ... es solo que ahora están definidos para no hacer nada. No obtendrá ningún tipo de error, es solo que no pasará nada. (Bueno, supongo que el desbordamiento de la pila ocurrirá eventualmente ...)

Cualquier programa que se ejecute bajo Linux / x86 (-64)

Este programa está escrito en C, pero puede interrumpir la ejecución de cualquier programa que se ejecute en Linux / x86 (-32 o -64). Lo antepone a la invocación de la línea de comandos del programa que desea interrumpir.

Utiliza la API del depurador para evitar que el programa de destino produzca resultados. Específicamente, todas las llamadas del sistema que pueden comunicar algo al mundo fuera del proceso (más obviamente write, por supuesto, pero también openal crear un archivo, la mayor parte de la API del socket, killcuando se aplica a otro proceso, ...) fallará como si no estuvieran implementados. _exitestá permitido, pero el código de salida se sobrescribe con un cero.

A diferencia de la edición anterior de esta respuesta, muchos programas pueden ejecutarse casi hasta su finalización en estas condiciones; es solo que todo su trabajo se desperdicia. Por ejemplo, si lo hace ./no-syscalls /bin/ls(suponiendo que GNU coreutils ls) lee todo el directorio y lo formatea, y luego writefallan todas las llamadas para producir resultados. (Sin embargo, cualquier cosa que necesite abrir un canal de comunicación bidireccional, como todos los clientes X11, fallará en ese momento. Pensé en permitir socketpero no send, pero parecía demasiado probable que se abrieran las lagunas).

Hay varias opciones de línea de comandos para modificar el comportamiento;

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

Los programas vinculados dinámicamente ni siquiera saldrán del vinculador dinámico en -emodo. -Sobviamente abre un gran vacío en la política, pero puede ser entretenido ver que los programas se quejan de que nada funciona, por ejemplo

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

Tiene que leer la salida del registro con /usr/include/asm*/unistd.habrir en otra ventana, porque esto ya es lo suficientemente largo.

Lamentablemente, las interfaces del depurador que esto usa son solo débilmente consistentes en las implementaciones de Unix y son intrínsecamente específicas de la CPU. Sería relativamente sencillo portarlo a otras arquitecturas de CPU (solo agregue las definiciones apropiadas de SYSCALL_*_REG), y probablemente sea ​​posibleptrace portarlo a cualquier Unix que tenga , pero es posible que deba manipular la lista blanca de syscall ampliamente y lidiar con divergencias en 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));
    }
  }
}

Texas

\catcode`\\=10

No estoy seguro de que esto realmente funcione, pero en teoría esto debería romperse \como personaje de escape, dejándote sin forma de arreglarlo. Normalmente, TeX puede leer y escribir archivos, ahora no puede escribir nada que dependa de la lógica. Por lo tanto, el lenguaje ahora está roto como lo define OP.

EDITAR: Otros comandos kill tomados de los comentarios (aunque ambos pueden violar la regla del código debe ser ejecutado):

• \def\fi{}\iffalseby smpl crea una rama si no se puede cerrar
• \catcode13=9%por iwillnotexist idonotexist crea un comentario interminable

Rasguño

Se when [timer v] > (0)ejecutará tan pronto como se inicialice el código, que si está en el editor es incluso antes de comenzar el código. Esto when I receive (join[][])provocará un error cada vez que se transmita algo, pausando la ejecución del código si tiene la versión para desarrolladores de Flash. La breakfunción creará clones y activará el error de transmisión. Cada clon durará dos segundos y luego se eliminará a sí mismo, ejerciendo presión sobre la pila. Y cada clon responderá al when [timer v] > (0), ejecutando la breaksubrutina y reiniciando el temporizador, lo que hace que el código del temporizador se ejecute nuevamente. Además, cada clon responderá también a cada error de transmisión, lo que significa que el número de errores por evaluación breakes el número de clones al cuadrado. ¿Olvidé mencionar que la breakfunción tienerun without screen refreshcomprobado, haciendo que el editor se congele, se sacuda y se retrase, así como la memoria de captura y asignación. Y maximizando la CPU.

Cualquier código agregado en cualquier lugar con esta ejecución se verá incapaz de crear clones (límite de 300 clones superado), así como de calentar y bloquear la computadora que lo ejecuta. Y agarrando memoria hasta que no haya más para agarrar, dejando que las variables se comporten mal.

Y, después de que haya demasiado retraso para activar el when [timer v] > (0)bloqueo, seguirá ejecutándose break.

Gracias a @towerofnix por recordarme el when I receiveproblema técnico que encontré hace un tiempo y por darme la idea run without screen refresh. Si te gustó esto, aquí está el original: https://codegolf.stackexchange.com/a/61357/43394

Mathematica / Wolfram Language

Mathematica es un lenguaje interpretado en el que los nombres de los comandos son símbolos que el programador puede manipular. No puede eliminar operadores integrados, pero puede sobrecargarlos o modificar su función. Lo siguiente codifica el comando "Con", que es necesario para la asignación a variables incluso internamente. Este cambio evita que el núcleo contenga argumentos sin evaluar hasta que se complete la asignación, y mata el lenguaje completamente.

ClearAttributes["With", HoldAll]

Si este comando se ejecuta en una sesión interactiva o dentro de un bloque de código, Mathematica ni siquiera podrá agregar 1+1(el mensaje de error resultante es de una página, así que no lo incluiré aquí).

PHP

Me sorprende que realmente funcione, pero al cerrar STDOUTy STDERRsuprimir toda la salida. Para asegurarnos de que no se vuelvan a abrir, abrimos /dev/nulltres veces para reasignar los descriptores de archivo 0, 1 y 2:

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

// insert program here

Más sobre eso: https://stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

Lote de DOS (antes de Windows 95, creo)

CTTY

Emitido sin argumentos, esto desconecta la línea de comando del terminal. Cualquier otro intento de leer entradas o generar salidas no hace nada.

En caso de que quiera saber cómo usar CTTY correctamente:

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

Un archivo por lotes un poco más potente incluso podría responder al módem y conectar lo que haya marcado a CTTY.

Lisp común

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

Espero que no necesites esos paréntesis iniciales.

Esta es una macro de lector que le dice al Lisp Reader que reemplace cada instancia de (con una llamada a (lambda (x y) ()), una función que toma dos argumentos y no devuelve nada. Así, por ejemplo, se leería (foo)como foo), interpretar foocomo una variable y luego tirar un error entre paréntesis sin emparejar en el 0.

Rasguño

Aquí hay un ejemplo bastante simple que bloqueará su navegador (y, en teoría, su computadora):

Dejé esto funcionando durante unos veinte segundos, luego perdí 2,65 GB de memoria para Scratch. Solo un momento después y 5 GB se habían ido.

Le recomiendo que tenga un medio para forzar el cierre de Adobe Flash o su navegador web antes de ejecutar esto.

^{Yo realmente quería hacer una respuesta fría como el clear(this)JS un rasguño, pero lamentablemente no tiene ningún maneras de hacer eso. ¡Siéntase libre de actualizar esta publicación (o hacer la suya propia) si SI encuentra otra forma de hacer que Scratch sea inutilizable!}

Jue

::=

Con una nueva línea al final

El lenguaje se basa en definir conjuntos de reglas y ::=denota el final del conjunto de reglas. Es imposible hacer NADA sin definir las reglas que lo hacen, así que, independientemente de lo que ponga después ::=, no puede pasar nada.

Respuesta alternativa

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

(y así sucesivamente para cada carácter en todo Unicode, incluidos los anteriores al Acarácter y los caracteres no imprimibles). Esto requiere la opción de línea de comandos -r.

MATLAB

El siguiente código hace que el entorno sea completamente inutilizable ¹ :

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

Esto anula la builtinfunción y la clearfunción con nuevos identificadores de funciones anónimas que simplemente regresan falsecada vez que intenta llamar a estas funciones. La builtinfunción asegura que si hay algún funciones personalizadas se escriben en MATLAB que son el mismo nombre que los que están incorporados a MATLAB (cosas como sum, max, min, etc.), que son capaces de llamar a estas ambigüedades en lugar de las funciones sobrecargadas . Del mismo modo, clearle ofrece la posibilidad de borrar todas las variables que están declaradas actualmente para que pueda comenzar de nuevo. Al eliminar estas capacidades, no hay forma de que pueda usar MATLAB a menos que reinicie el programa.

En MATLAB R2015a, también recibo el siguiente mensaje:

El espacio de trabajo son las variables que se declaran actualmente en el entorno para que pueda usarlas para más adelante. Esto deshabilita permanentemente el espacio de trabajo, por lo que las variables que intente crear no se guardarán y, por lo tanto, no se podrá avanzar al ejecutar líneas de código en MATLAB.

^{1: El crédito va al usuario Dev-iL que descubrió originalmente la idea.}

///

/\///

La única operación en /// se repite sustitución de cadenas, como esto: /pattern/replacement/.

Este código elimina todos /, de esa manera no se puede usar la sustitución repetida de cadenas, por lo que básicamente todo lo que escriba después se imprimirá (excepto /s).

Todavía puedes usar \s, pero eso no te ayudará mucho.

Befunge-96

'~h

El código del usuario puede seguir a cualquier parte después de esta secuencia, siempre que estos sean los primeros tres caracteres de la fuente.

El 'comando (modo de cadena de un disparo) empuja el valor ASCII de la ~pila a la pila (es decir, 126), y el hcomando establece lo que se conoce como el Delta Holístico con ese valor. Para aquellos que no están familiarizados con Befunge-96, el Delta Holístico es un desplazamiento que se agrega al valor de cada byte de comando que encuentra el intérprete.

Una vez que el delta se establece en 126, el único comando válido que se puede generar es ~(entrada de caracteres), a través de un byte nulo en la fuente. Cualquier otra cosa que no sea un byte nulo se traduciría en un valor mayor que 126, y ninguno de esos valores serían comandos válidos de Befunge.

Creo que es seguro decir que esto no permitiría calificar como lenguaje de programación.

Abucheo

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

Y luego, en otro lugar del proyecto,

harmless

Una macro simple con un nombre que suena inofensivo, pero un efecto increíblemente frustrante. El compilador de Boo utiliza una canalización de varios pasos que comienza con el análisis de la fuente en un AST y termina con la generación de código. (Generalmente. Se puede reconfigurar para varias aplicaciones). Cada paso intermedio realiza varias operaciones en el AST.

A mitad de camino está la etapa de expansión de macros, en la que las macros se ejecutan en el contexto del compilador. ¿Recuerdas el bit en el último párrafo, acerca de que la tubería es reconfigurable? Si, durante la expansión de macro, invoca una macro que borra la tubería, no se mostrará ningún error al usuario, pero todos los pasos posteriores a la expansión de macro (incluida la generación de código) ya no están allí. Así que terminas con algo que parece una compilación exitosa, no se muestran mensajes de error, ¡pero por alguna razón no se produce ningún binario! Garantizado para conducir incluso a los mejores solucionadores de problemas por el muro, si oculta bien la macro y la invocación.

NGN / APL

NGN / APL permite redefinir primitivas, por lo que redefinir ( ←) todas las funciones primitivas para ⊢("pasar a través": ambas ⊢3y 2⊢3da 3) hace que el lenguaje sea completamente inútil:

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

Pruébalo aquí

Ruby (29 caracteres)

class Object;def send;end;end

Como 'enviar' se usa internamente cada vez que se llama a un método dentro de Ruby, y dado que todos los objetos heredan de la clase Object. Esto debería detener cualquier método que se ejecute.

Dato curioso: esto es perfectamente sólido en teoría. Pero parece, por alguna razón, no obstaculizar el lenguaje Ruby. No tengo idea de por qué es posible ejecutar este código y luego seguir usando un entorno abierto de Ruby.

Tcl

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

Esto elimina todas las palabras clave del idioma excepto ify rename.

El código anterior haría que cualquier código nuevo produjera un error. Por lo tanto, es discutible si el nuevo código insertado realmente se "ejecuta". A continuación se muestra una versión que ejecuta un nuevo código pero no hace nada porque cambia todas las palabras clave (excepto ify proc) a una no operación:

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

En lugar de eliminar palabras clave, este código las reemplaza con una función que no hace nada.

(Nota: estoy usando "palabras clave" muy libremente aquí porque Tcl no tiene palabras clave, solo funciones)

Hoon

=<  ~
(your code)

Hoon es un extraño. Es bastante diferente a otros lenguajes de programación, no solo en sintaxis sino también en semántica. Sin embargo, a diferencia de los idiomas como Hexagony, no fue hecho para ser esotérico a propósito.

Hoon compila a Nock , una máquina virtual basada en un combinador mínimo. Nock es estúpido: la especificación se puede comprimir a 340 bytes. La única operación matemática está aumentando. Todo es un sustantivo: un átomo (bignum) o una celda (par de sustantivos), con todo el modelo de memoria dispuesto en un árbol binario acíclico inmutable. El único resultado es el sustantivo al que se reduce su expresión.

Debido al extraño objetivo de compilación, Hoon también es extraño: es completamente puro. Hoon compila una expresión de Nock que se evalúa en un "contexto". Todo el núcleo y stdlib, junto con todas las variables, se pasan implícitamente al programa por el contexto.

Para hacer que Hoon sea inutilizable solo usamos =<, que es "evaluar a en el contexto de b". Siempre estamos evaluando ~, que es cero. No importa lo que bhaga, no puede cambiar el valor al que se reduce, y dado que no puede tener efectos secundarios, no puede hacer entrada o salida.

Nota al margen: como en realidad no se puede solicitar la entrada de Hoon (¡pureza!), Según las reglas, en realidad no es un lenguaje de programación. La entrada es a través de argumentos de función, la salida a través de valores de retorno (o ~&, que es más una función de depuración de printf y es transparente para el programa).

Para que un programa obtenga entrada en Urbit, en realidad escribe un programa que devuelve una función que acepta entrada, y el shell pregunta en su nombre y pasa a la devolución de llamada.

Taxi, 2354 bytes.

Este pequeño programa simplemente pasa el taxi en un gran viaje a través de Townsburg, quedando sin gasolina. Cualquier código que ejecute después de esto generará un error rápidamente error: out of gas. E incluso si pudieras llegar a una estación de servicio, lo cual no creo que sea posible, no podrías obtener gasolina, ya que no se ha recogido dinero, ya que no hay pasajeros.

Go to Trunkers: west, 1st right, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st left, 1st left, 1st right.

JavaScript en el navegador

Bueno, al menos en IE11.

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

Inhabilita la escritura en el documento, la escritura en la variable global y el regreso de la función.

¡Comenta si me he perdido un método de salida!

Python 2, increíblemente grande

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

Esta cantidad increíblemente grande de código es una reactivación del rexecmódulo antiguo (abandonado en Python 2.3) con un montón de módulos nuevos agregados a la lista "ok" y un montón de debilidades corregidas (incluido el object.__subclasses__()método que ha hecho al menos otras dos python respuestas no válidas).

Gran parte de este código (el __init__método de la RExecclase y toda la ModuleImporterclase) se copia de la biblioteca estándar de Python con pequeñas modificaciones.