Tente escrever algum código em sua linguagem e faça com que não satisfaça mais nossos critérios de ser uma linguagem de programação .

Uma linguagem satisfaz nossos critérios (versão simplificada para este desafio) de ser uma linguagem de programação se:

• Ele pode ler a entrada do usuário representando tuplas de números inteiros positivos de alguma forma.
• Pode gerar pelo menos dois resultados possíveis diferentes, dependendo da entrada.
• É possível pegar dois números inteiros positivos e adicioná-los (e o resultado pode afetar a saída).
• Ele pode pegar um número inteiro positivo e decidir se é um primo (e o resultado pode afetar a saída).
• Para os fins deste desafio, qualquer tipo de saída que não seja um método de saída permitido para um desafio normal é ignorado. Portanto, não importa se o programa também pode tocar uma música ou postar via HTTP, etc.
• Atualização: Você também pode escolher um ou alguns dos métodos de saída permitidos e ignorar todos os outros. Mas você deve usar a mesma definição em todos os lugares nos seguintes critérios. E se o seu programa pode desativar mais de um método de saída - isso vale mais votos.

Exemplos como impossibilidade de saída ou desativação de todas as construções de loop, para que não seja possível fazer o teste de primalidade e garantir que o usuário não possa reativá-las.

Você deve deixar um local para inserir um novo código. Por padrão, está no final do seu código. Se considerarmos colocar o código-fonte nesse local na sua resposta e executar o código completo como um programa completo, o intérprete de um novo idioma, esse idioma não deve atender aos critérios.

Mas o código inserido deve ser executado de maneira semelhante a uma linguagem que atenda aos critérios:

• O código inserido deve ser gramaticalmente o mesmo que algo (digamos, é um bloco de código nos seguintes critérios) que geralmente satisfaz os critérios, da perspectiva de quem deseja escrever um marcador de sintaxe. Portanto, não pode estar em uma sequência, comentário, etc.
• O código inserido deve ser realmente executado, de forma a satisfazer os critérios. Portanto, ele não pode estar em uma função não utilizada ou sizeofem C, você não pode apenas executar apenas uma parte não funcional no código e não pode colocá-lo após um loop infinito, etc.
• Você não pode limitar o número de possíveis programas gramaticalmente corretos possíveis gerados dessa maneira. Se já existe algo como um limite de comprimento no idioma que você está usando, ele não deve atender aos critérios, mesmo que esse limite seja removido.
• Você não pode modificar ou "esgotar" o conteúdo da entrada / saída, mas pode impedir que eles sejam acessados.
• Esses critérios geralmente se aplicam apenas a idiomas sem E / S explícita:
  • Seu código deve redirecionar a entrada do usuário (que contém informações de tamanho arbitrário) para o código inserido, se um bloco de código normalmente não conseguir obter a entrada do usuário direta / explicitamente no idioma que você está usando.
  • Seu código deve imprimir o valor retornado do código inserido, se um bloco de código normalmente não é capaz de produzir coisas direta / explicitamente no idioma que você está usando.
  • Caso você imprima o valor retornado e ele seja digitado no idioma que você está usando, o tipo retornado deverá ter 2 valores praticamente possíveis possíveis. Por exemplo, você não pode usar o tipo struct {}ou struct {private:int x;}em C ++.

Este é um concurso de popularidade. A resposta válida mais votada (para que ninguém tenha detectado um erro ou todos os erros sejam corrigidos) vence.

Esclarecimentos

• Você não deve modificar o código no formato de texto, mas pode alterar a sintaxe antes que o código seja interpretado ou compilado.
• Você pode fazer outras coisas enquanto o código estiver em execução. Mas a razão de não atender aos critérios deve estar dentro do próprio código inserido. Pode ocorrer um erro devido à interferência de outro encadeamento, mas não apenas ser morto por outro encadeamento.
• Todas as especificações basicamente significam que deve ser gramaticalmente provável que satisfaça os critérios se todos os embutidos não forem alterados, mas não o fizerem realmente. Tudo bem se você encontrar soluções alternativas não gramaticais, como passar os parâmetros para o bloco de código corretamente, mas torná-los incapazes de serem usados ​​de alguma maneira.
• Novamente, o código inserido deve ser realmente executado. O código após um loop infinito ou falha é considerado "realmente não executado", portanto, não é válido . Essas respostas podem ser interessantes, mas já existem outras perguntas infinitas ou repetidas neste site, e você pode encontrar uma resposta mais apropriada. Caso contrário, considere fazer uma nova pergunta. Exemplos dessas perguntas são:
  • Loop infinito mais curto, sem saída
  • Por que não está terminando?
  • Loop sem 'loop'
  • Desafio: escreva um pedaço de código que se encerre
  • Erros ridículos de tempo de execução
  • Bater seu compilador favorito

Entre os melhores

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 JavaScript

Isso tornará o idioma completamente inutilizável.

clear(this);

Não é legal como o JavaScript tem uma função tão boa para se destruir?

Isso é bastante simples, a clearfunção esvazia completamente um objeto. thisrefere-se ao objeto global que limpa tudo, incluindo construtores e funções.

Porque isso limpa tudo , fazer qualquer coisa , até definir um literal gera um erro, tornando a linguagem completamente inútil: _{* O ambiente REPL não é necessário. Usa o mecanismo SpiderMonkey (shell, não navegador), o mecanismo JS original.}

Emmental

;#33!

Eu sei que isso não é código de golfe, mas a ferramenta certa para o trabalho, você sabe ...

O código do usuário pode ser inserido após o !.

Emmental é um esolang interessante, baseado na reescrita do intérprete. Cada símbolo único (incluindo os embutidos) pode ser redefinido como um programa Emmental arbitrário. A linguagem depende tanto desse recurso que não fornece nenhuma construção de loop. Em vez disso, você define comandos recursivos que aparecem em suas próprias definições.

Essa redefinição acontece via !, que lê um caractere da pilha e, em seguida, lê uma string da pilha até encontrar a ;. O caractere é redefinido para significar o programa representado por essa sequência.

Isso significa que podemos desativar os recursos de loop do Emmental, redefinindo- ! se como o programa vazio. Embora todo o outro código Emmental ainda funcione perfeitamente, e muitos dos critérios de uma linguagem de programação ainda sejam cumpridos, é impossível redefinir mais símbolos. Sem esse recurso (e, portanto, sem poder fazer um loop), o Emmental não pode mais testar se um número é primo.

PHP

Pode-se matar completamente o PHP definindo o limite de memória como 1.

Ele morrerá completamente.

Tente o seguinte:

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

    //code here

Isso não deve gerar nenhum erro, pois não há memória suficiente para isso.

Você pode ler mais sobre a memory_limitdiretiva

Se o anterior for inválido, pode-se usar buffers de saída:

<?php
    ob_start();

    //code here

    ob_clear();

Isso remove completamente qualquer saída. Como o buffer de saída ainda está aberto, outras coisas deixadas acidentalmente após o código também não serão mostradas.

Usando a idéia 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();

Isso evitará o problema de excluir o buffer de saída iniciado automaticamente, usado para capturar a saída a ser compactada.

Isso também evita que o buffer de saída seja excluído ou liberado (enviado ao navegador). Para reforçar isso, um manipulador de saída é adicionado, que sempre retorna uma string vazia.
Correr ob_end_flush(); echo "Hello, world!";não produzirá nada, mas enviará a saída com uma planície ob_start();.

Agradecemos a @LucasTrzesniewski por expor esse problema!

código de máquina x86 em modo real (=> quase qualquer programa DOS)

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

ie

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

Espero que você não esteja muito apegado à sua mesa de interrupção.

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: Contra-contramedidas estão fazendo este gigante :(

Redireciona stdin e stdout para fluxos nulos e substitui args por uma matriz vazia. Também usa enormes quantidades de hacks de reflexão para garantir que o IO padrão esteja realmente oculto. Por fim, define um gerenciador de segurança para garantir que o IO padrão não possa ser recriado e que os programas não possam definir o código de saída.

Lua

_ENV=""

Em Lua, _ENVé o ambiente em que todas as variáveis ​​globais, funções, tabelas, etc. são armazenadas. Definir como uma string vazia significa que você não pode definir nada de novo, e todas as funções e variáveis ​​são apagadas. Isso significa que você não pode produzir nada, receber informações ou praticamente fazer qualquer coisa.

Linguagem de programação 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]

No SPL, o analisador embutido que é baixado com o programa segue regras muito específicas sobre o que pode acontecer no script. Uma dessas regras é que apenas dois personagens podem estar no palco ao mesmo tempo. Além disso, fazer um personagem sair do palco que nunca esteve no palco irá confundi-lo. O mesmo vale para adicionar um personagem ao palco que já está no palco. Quando o analisador recebe um erro, ele se recusará a fazer QUALQUER COISA; você literalmente precisa desligar completamente o programa e o analisador e, em seguida, reiniciar tudo.

PS Se você não tem idéia de como esse idioma funciona, pesquise no Google. É incrivel.

Conversa fiada

Não tenho certeza se isso se qualifica:

Smalltalk := Nil.

Isso exclui todo o ambiente de tempo de execução, interrompendo o mecanismo de objetos. A única maneira de corrigir isso é forçar o encerramento do processo e reiniciar a partir do backup.

Para quem não sabe, o modo como o [Visual Works] Smalltalk funciona é um pouco estranho. É como um mini-OS. Ao iniciar o Smalltalk, você carrega uma "imagem de memória" na RAM e ela continua sendo executada de onde parou. Todo o IDE do Smalltalk é escrito em Smalltalk e é dinamicamente modificável.

Em particular, Smalltalké um dicionário que contém todas as variáveis ​​globais. Mais particularmente, toda vez que você declara uma nova classe, uma variável global com esse nome é criada, apontando para o Classobjeto da sua nova classe. Portanto, definir Smalltalkcomo Nil(basicamente nulo) exclui todas as classes em todo o sistema. Até os manipuladores de eventos da GUI ficam loucos.

Não faço ideia por que essa variável é gravável. Provavelmente porque é uma variável global e, portanto, existe como uma entrada dentro de si. (Sua cabeça ainda está doendo? Eu mencionei que todo objeto tem uma classe e classes são objetos, então toda classe tem uma classe? A classe de uma classe é chamada de metaclasse, mas uma metaclasse também é um objeto, o que, portanto, tem uma aula...)

Você provavelmente poderia obter um efeito semelhante limpando o dicionário em vez de substituí-lo por nulo. De fato, há várias coisas que você pode codificar para excluir todas as classes do sistema, deixando-o incapaz de fazer qualquer coisa. Mas como o compilador Smalltalk real também é uma classe ... qualquer coisa que quebra a linguagem também quebra todo o IDE, então ...

Haskell

Existem algumas possibilidades aqui.

Idéia chata # 1: defina mainpara não fazer nada. Agora, independentemente do outro código que você escreve, ele nunca pode ser executado. (A menos que você o execute manualmente a partir do REPL.)

Idéia chata nº 2: defina um módulo sem exportações públicas. Agora, independentemente do outro código que você escreve, ele nunca pode ser executado.

Ideia interessante: desative todas as importações.

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

Agora você pode definir funções que são visíveis e podem ser executadas ... mas elas não podem fazer nada. Todos os tipos e funções padrão de Haskell agora estão ocultos. (Com exceção de algumas coisas realmente profundamente conectadas ao idioma.)

Mais particularmente, você não pode executar nenhuma E / S. Você também não pode fazer aritmética de precisão da máquina. (Como Int, Doubleetc, agora estão indefinidos.)

Você ainda pode escrever funções de cálculo lambda que realizam algum cálculo real. Você simplesmente não consegue obter ou retirar dados da coisa. Mas é claro que você poderia escrever outro módulo separado que chame o Fubarmódulo acima e faça E / S em seu nome (provando assim que o código é executado e faz coisas).

Algumas sutilezas:

• A foo = foodeclaração fictícia é necessária para impedir que alguém adicione importações adicionais. (As importações não podem aparecer após as declarações.)

• Existem várias extensões de idioma Haskell não padrão que permitem sair dessa situação. Mas as extensões de idioma precisam ser ativadas com um pragma do compilador na parte superior do arquivo. (Ou com uma opção de linha de comando para o compilador. Na verdade, não posso impedir isso!)

PostScript

Sim, PostScript é uma linguagem de programação. Além disso, é uma linguagem de programação em que todas as construções de linguagem são funções definidas pelo sistema, que podem ser redefinidas ...

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

Em inglês:

• Crie um dicionário de 1.000 elementos vazio e nomeie-o Magic.
• Para cada chave systemdict, adicione a mesma chave a Magic, com uma definição vazia (" {}").
• Empurre Magicpara o topo da pilha do dicionário.

A partir deste momento, todo comando da linguagem PostScript é definido para não fazer nada. AFAIK, é impossível escapar dessa condição.

(Tecnicamente, você não está "destruindo" as definições antigas, apenas as obscurece. Se você ainda pudesse executá-las end, isso sairia Magicda pilha do dicionário, desprotegendo todos os comandos e devolvendo sua vida a você. endem si também é sombreado ... não fará nada agora.)

Observe que todos os comandos ainda serão executados ... é que agora eles estão definidos para não fazer nada. Você não receberá nenhum tipo de erro, apenas nada acontecerá. (Bem, suponho que o estouro da pilha acabe por acontecer ...)

Qualquer programa em execução no Linux / x86 (-64)

Este programa é escrito em C, mas pode interromper a execução de qualquer programa em execução no Linux / x86 (-32 ou -64). Você o anexa à chamada de linha de comando do programa que deseja interromper.

Ele usa a API do depurador para impedir que o programa de destino produza qualquer saída. Especificamente, todas as chamadas do sistema que podem comunicar algo ao mundo fora do processo (obviamente write, é claro, mas também openao criar um arquivo, a maior parte da API do soquete, killquando aplicada a outro processo, ...) falhará como se não estivessem implementados. _exité permitido, mas o código de saída é substituído por um zero.

Diferentemente da edição anterior desta resposta, muitos programas podem ser executados quase sob essas condições; é que todo o trabalho deles é desperdiçado. Por exemplo, se você o fizer ./no-syscalls /bin/ls(assumindo o GNU coreutils ls), ele lê o diretório inteiro e o formata e, em seguida, todas as writechamadas para produzir saída falham. (Qualquer coisa que precise abrir um canal de comunicação bidirecional, no entanto, como todos os clientes X11, falhará nesse ponto. Pensei em permitir, socketmas não send, mas parecia muito provável abrir brechas.)

Existem várias opções de linha de comando para ajustar o comportamento;

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

Programas vinculados dinamicamente nem sairão do vinculador dinâmico no -emodo. -Sobviamente, abre um enorme buraco na política, mas pode ser divertido assistir a programas queixam-se de nada funcionar, por exemplo

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

Você precisa ler a saída do log com /usr/include/asm*/unistd.habrir em outra janela, porque isso já é bastante longo.

Infelizmente, as interfaces do depurador que isso usa são fracamente consistentes nas implementações do Unix e são intrinsecamente específicas da CPU. Seria relativamente simples portá-lo para outras arquiteturas de CPU (basta adicionar definições apropriadas de SYSCALL_*_REG) e provavelmente é possível portá-lo para qualquer Unix que possua ptrace, mas talvez você precise mexer com a lista branca do syscall extensivamente, além de lidar com divergências no ptrace.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /* If we get here, we are the parent. */
  for (;;) {
    pid_t rv = waitpid(pid, &status, WUNTRACED);
    if (rv != pid) {
      perror("waitpid");
      kill(pid, SIGKILL);
      exit(1);
    }
    if (!WIFSTOPPED(status)) {
      if (WIFEXITED(status))
        printf("Program exited, status = %d\n", WEXITSTATUS(status));
      else if (WIFSIGNALED(status))
        printf("Program killed by signal %d\n", WTERMSIG(status));
      else {
        printf("Un-decodable status %04x\n", status);
        kill(pid, SIGKILL); /* just in case */
      }
      exit(0);
    }
    if (WSTOPSIG(status) == SIGSTOP && !trace_active) {
      /* This is the raise(SIGSTOP) on the child side of the fork. */
      trace_active = 1;
      xptrace(PTRACE_SEIZE, pid, 0, (void*)PTRACE_O_TRACESYSGOOD);
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    }
    else if (WSTOPSIG(status) == (SIGTRAP|0x80)) {
      if (last_syscall == SYS_unimplemented) {
        last_syscall = GET_REG(pid, NUMBER);
        /* The child process is allowed to execute normally until an
           execve() succeeds.  */
        if (after_execve && deny_syscall(pid, last_syscall,
                                         deny_all, allow_stderr)) {
          last_allowed = 0;
          SET_REG(pid, NUMBER, SYS_unimplemented);
        } else {
          last_allowed = 1;
          if (log_allowed) {
            /* Log this now, we may not get another chance. */
            printf("syscall %ld...\n", last_syscall);
          }
        }
      } else {
        if (last_allowed ? log_allowed : log_denied) {
          long scret = GET_REG(pid, RESULT);
          printf("syscall %ld%s = %ld\n",
                 last_syscall, last_allowed ? "" : " (denied)", scret);
        }
        if (last_allowed && (last_syscall == SYS_execve ||
                             last_syscall == SYS_execveat)) {
          long scret = GET_REG(pid, RESULT);
          if (scret == 0)
            after_execve = 1;
        }
        last_syscall = SYS_unimplemented;
      }
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    }
    else if (WSTOPSIG(status) == SIGTRAP) {
      /* Swallow all SIGTRAPs, they are probably spurious debug events. */
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    } else {
      /* Allow all normal signals to proceed unmolested. */
      if (log_allowed) {
        printf("process received signal %d\n", WSTOPSIG(status));
      }
      xptrace(PTRACE_SYSCALL, pid, 0, (void*)(uintptr_t)WSTOPSIG(status));
    }
  }
}

TeX

\catcode`\\=10

Não tenho certeza se isso realmente funcionará, mas, em teoria, isso deve se \transformar em um caractere de escape, deixando você sem maneira de corrigi-lo. Normalmente, o TeX pode ler e gravar arquivos, agora não pode escrever nada que dependa da lógica. Portanto, o idioma agora está quebrado, conforme definido pelo OP.

EDIT: Outros comandos kill retirados dos comentários (embora ambos possam violar a regra de código deve ser executado):

• \def\fi{}\iffalsepor smpl cria um ramo que não pode ser fechado
• \catcode13=9%por iwillnotexist idonotexist cria um comentário sem fim

coçar, arranhão

Ele when [timer v] > (0)será executado assim que o código for inicializado, o que, se você estiver no editor, é antes mesmo de iniciar o código. O when I receive (join[][])causará um erro para ser jogado a cada hora é transmitido qualquer coisa, parando a execução de código se tiver a versão desenvolvedor do Flash. A breakfunção criará clones e acionará o erro de transmissão. Cada clone único dura dois segundos e se exclui, pressionando a pilha. E todo clone responderá à when [timer v] > (0), executando a breaksub - rotina e redefinindo o timer, o que faz com que o código do timer seja executado novamente. Além disso, cada clone também responderá a todos os erros de transmissão, significando que o número de erros por avaliação breaké o número de clones ao quadrado. Esqueci de mencionar que a breakfunção temrun without screen refreshverificado, fazendo com que o editor congele, sacudir e atrasar, além de capturar e alocar memória. E maximizando a CPU.

Qualquer código adicionado em qualquer lugar com essa execução não será capaz de criar clones (limite de 300 clones ultrapassado), além de aquecer e travar o computador que a executa. E pegar memória até que não haja mais nada para pegar, deixando as variáveis ​​se comportando mal.

E, depois que houver muito atraso para acionar o when [timer v] > (0)bloco, ele ainda estará em execução break.

Obrigado a @towerofnix por me lembrar sobre a when I receivefalha que encontrei há um tempo e por me dar a ideia run without screen refresh. Se você gostou, aqui está o original: https://codegolf.stackexchange.com/a/61357/43394

Linguagem Mathematica / Wolfram

O Mathematica é uma linguagem interpretada na qual os nomes de comandos são símbolos que podem ser manipulados pelo programador. Você não pode excluir operadores internos, mas pode sobrecarregá-los ou modificar sua função. A seguir, embaralha o comando "Com", necessário para atribuir às variáveis ​​mesmo internamente. Essa alteração evita que o kernel mantenha os argumentos sem avaliação até a conclusão da atribuição e mata o idioma completamente.

ClearAttributes["With", HoldAll]

Se esse comando for executado em uma sessão interativa ou dentro de um bloco de código, o Mathematica nem poderá adicionar 1+1(a mensagem de erro resultante tem cerca de uma página, por isso não a incluirei aqui).

PHP

Estou surpreso que ele realmente funcione, mas feche STDOUTe STDERRsuprima toda a saída. Para garantir que eles não serão abertos novamente, abrimos /dev/nulltrês vezes para reatribuir os descritores de arquivo 0, 1 e 2:

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

// insert program here

Mais sobre isso: https://stackoverflow.com/questions/937627/how-to-redirect-stdout-to-a-file-in-php

Lote DOS (antes do Windows 95, acredito)

CTTY

Emitido sem argumentos, isso desconecta a linha de comando do terminal. Qualquer tentativa adicional de ler entrada ou gerar saída não faz nada.

Caso você queira saber como usar o CTTY corretamente:

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

Um arquivo em lotes um pouco mais poderoso pode até atender o modem e conectar o que for discado ao CTTY.

Lisp comum

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

Espero que você não precise desses parênteses de abertura.

Essa é uma macro do leitor que informa ao Lisp Reader para substituir cada instância de (por uma chamada para (lambda (x y) ()), uma função que recebe dois argumentos e não retorna nada. Assim, por exemplo, seria lido (foo)como foo), interpretado foocomo uma variável e, em seguida, lançado um erro de parêntese inigualável 0.

coçar, arranhão

Aqui está um exemplo bastante simples que irá travar seu navegador (e, em teoria, seu computador):

Deixei isso em execução por cerca de vinte segundos e perdi 2,65 GB de memória para o Scratch. Apenas um momento depois e 5 GB se foram.

Eu sugiro que você tenha um meio de forçar a saída do Adobe Flash ou do seu navegador antes de executar isso!

^{Eu realmente queria dar uma resposta legal como a clear(this)JS, mas, infelizmente, o Scratch não tem maneiras de fazer isso. Sinta-se livre para atualizar este post (ou criar o seu próprio) se você encontrar outra maneira de tornar o Scratch inutilizável!}

Qui

::=

Com uma nova linha no final

A linguagem thue depende da definição de conjuntos de regras e a ::=denota o final do conjunto de regras. É impossível fazer QUALQUER COISA sem definir regras que o façam, portanto, independentemente do que você colocar depois ::=, nada pode acontecer.

Resposta alternativa

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

(e assim por diante para todos os caracteres em todo o Unicode, incluindo aqueles antes do Acaractere e caracteres não imprimíveis). Isso requer a opção de linha de comando -r.

MATLAB

O seguinte trecho de código torna o ambiente completamente inutilizável ¹ :

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

Isso substitui a builtinfunção e a clearfunção por novas alças de função anônimas que simplesmente retornam falsetoda vez que você tenta chamar essas funções. A builtinfunção garante que se houver quaisquer funções personalizadas que você escreve no MATLAB que são o mesmo nome que aqueles que são internos para MATLAB (coisas como sum, max, min, etc.), que são capazes de chamar estes de forma inequívoca, em vez das funções sobrecarregadas . Da mesma forma, clearpermite limpar todas as variáveis ​​declaradas no momento, para que você possa começar novamente. Ao remover esses recursos, não há como você usar o MATLAB, a menos que reinicie o programa.

No MATLAB R2015a, também recebo a seguinte mensagem:

O Espaço de Trabalho são as variáveis ​​atualmente declaradas no ambiente para que você possa usá-las para mais tarde. Isso desativa permanentemente o espaço de trabalho, portanto, quaisquer variáveis ​​que você tentar criar não serão salvas e, portanto, nenhum progresso poderá ser feito ao executar linhas de código no MATLAB.

^{1: O crédito é destinado ao usuário Dev-iL, que originalmente descobriu a ideia.}

///

/\///

A única operação em /// é a substituição repetida de strings, assim: /pattern/replacement/ .

Esse código remove todos /, dessa forma, você não pode usar a substituição repetida de cadeias, então basicamente tudo o que você escreve depois disso será impresso (exceto/ s).

Você ainda pode usar \s, mas isso não ajudará muito.

Befunge-96

'~h

O código do usuário pode seguir em qualquer lugar após essa sequência, desde que esses sejam os três primeiros caracteres da fonte.

O 'comando (modo de seqüência única) envia o valor ASCII ~para a pilha (ou seja, 126), e o hcomando define o que é conhecido como Delta Holístico com esse valor. Para quem não conhece o Befunge-96, o Delta Holístico é um deslocamento que é adicionado ao valor de cada byte de comando que o intérprete encontra.

Depois que o delta é definido como 126, o único comando válido que pode ser gerado é ~(entrada de caractere), por meio de um byte nulo na fonte. Qualquer coisa que não seja um byte nulo seria traduzido para um valor maior que 126 e nenhum desses valores seriam comandos válidos do Befunge.

Eu acho que é seguro dizer que isso tornaria inelegível a qualificação como uma linguagem de programação.

Vaia

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

E então, em outro lugar do projeto,

harmless

Uma macro simples com um nome inofensivo, mas com um efeito surpreendentemente frustrante. O compilador Boo usa um pipeline de várias etapas que começa com a análise da fonte em um AST e termina com a geração de código. (Geralmente. Ele pode ser reconfigurado para vários aplicativos.) Cada etapa intermediária executa várias operações no AST.

No meio, está o estágio de expansão da macro, no qual as macros são executadas no contexto do compilador. Lembre-se da parte do último parágrafo, sobre o pipeline sendo reconfigurável? Se, durante a expansão da macro, você chamar uma macro que limpa o pipeline, nenhum erro será exibido ao usuário, mas todas as etapas após a expansão da macro (incluindo a geração de código) não estarão mais lá. Então você acaba com algo que parece uma compilação bem-sucedida - nenhuma mensagem de erro é exibida - mas, por alguma razão, não há binário produzido! Garantido para conduzir até os melhores solucionadores de problemas, se você ocultar bem a macro e a invocação.

NGN / APL

O NGN / APL permite redefinir as primitivas, portanto, redefinir ( ←) todas as funções primitivas para ⊢("passar": ambas ⊢3e 2⊢3doações 3) torna a linguagem completamente inútil:

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

Experimente aqui.

Ruby (29 caracteres)

class Object;def send;end;end

Como 'send' é usado internamente sempre que um método é chamado dentro do Ruby e como todos os objetos são herdados da classe Object. Isso deve interromper a execução de qualquer método.

Curiosidade: Isso é perfeitamente correto em teoria. Mas parece, por alguma razão, não prejudicar a linguagem Ruby. Não faço ideia por que é possível executar esse código e ainda usar um ambiente Ruby aberto.

Tcl

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

Isso remove todas as palavras-chave do idioma, exceto ife rename.

O código acima causaria qualquer erro no novo código. Portanto, é discutível se o novo código inserido é realmente "executado". Abaixo está uma versão que executa o novo código, mas não faz nada porque altera todas as palavras-chave (exceto ife proc) para uma não operação:

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

Em vez de excluir palavras-chave, esse código as substitui por uma função que não faz nada.

(Nota: estou usando "palavras-chave" muito livremente aqui porque o Tcl não possui palavras-chave, apenas funções)

Hoon

=<  ~
(your code)

Hoon é um estranho. É praticamente totalmente diferente de outras linguagens de programação, não apenas na sintaxe, mas na semântica. Ao contrário de idiomas como o Hexagony, no entanto, não foi feito para ser propositadamente esotérico.

Hoon compila para Nock , uma VM baseada em combinador mínimo. Nock é estúpido: a especificação pode ser compactada em 340 bytes. A única operação matemática está aumentando. Tudo é um substantivo: um átomo (bignum) ou uma célula (par de substantivos), com todo o modelo de memória disposto em uma árvore binária acíclica imutável. A única saída é o substantivo ao qual sua expressão se reduz.

Por causa do alvo de compilação estranho, Hoon também é estranho: é completamente puro. Hoon compila até uma expressão Nock que é avaliada em um "contexto". Todo o kernel e stdlib, junto com todas as variáveis, são passados ​​implicitamente para o programa pelo contexto.

Para tornar Hoon inutilizável, apenas usamos =<, que é "avaliar a no contexto de b". Estamos sempre avaliando ~, que é zero. Não importa o queb faça, ele não pode alterar o valor a que se reduz e, como não pode ter efeito colateral, não pode fazer entrada ou saída.

Nota lateral: Como você não pode realmente solicitar a entrada de Hoon (pureza!), Pelas regras não é realmente uma linguagem de programação. A entrada é via argumentos de função, a saída é via valores de retorno (ou ~&, que é mais um recurso de depuração printf e é transparente para o programa).

Para um programa obter entrada no Urbit, você realmente escreve um programa que retorna uma função que aceita entrada, e o shell pergunta em seu nome e passa para o retorno de chamada.

Táxi, 2354 bytes.

Este pequeno programa simplesmente dirige o táxi em um grande passeio de alegria por Townsburg, ficando sem combustível. Qualquer código que você executar após isso irá rapidamente erro com error: out of gas. E mesmo que você pudesse chegar a um posto de gasolina, o que eu acho que não é possível, você não conseguiria gasolina, pois nenhum dinheiro foi coletado, já que não há passageiros.

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 no navegador

Bem, pelo menos no IE11.

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

Desativa a gravação no documento, a gravação na variável global e o retorno da função.

Comente se perdi um método de saída!

Python 2, incrivelmente 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()

Essa quantidade insanamente grande de código é um renascimento do rexecmódulo antigo (abandonado no python 2.3) com um monte de novos módulos adicionados à lista "ok" e um monte de pontos fracos corrigidos (incluindo oobject.__subclasses__() método que criou pelo menos dois outros python respostas inválidas).

Um pouco desse código (o __init__método da RExecclasse e de toda a ModuleImporterclasse) é copiado da biblioteca padrão do python com pequenas modificações.