Sou desenvolvedor e não tenho vontade de fazer meu trabalho. Sei do XKCD que a melhor desculpa para relaxar é que seu código está compilando . Por isso, acho que preciso de um código que seja compilado para sempre! E como sou preguiçoso e não quero digitar muito, isso deve ser feito com o menor código possível.

Portanto, sua tarefa é escrever um programa que seja sintaticamente válido, mas fará com que o compilador insira um loop infinito.

Especificações

Você deve usar uma linguagem que tenha um compilador, obviamente.
Especifique a implementação usada em cada solução.
Isso é código-golfe , então a solução válida mais curta (em bytes) vence.
O compilador pode terminar de ficar sem memória ou espaço na pilha.

code-golf compile-time

— Esolanging Fruit
fonte

1

@obarakon Eu discordo. O código do outro desafio não pode ser portado para esse desafio com facilidade. Os desafios, enquanto os dois envolvem loop infinito, são fundamentalmente diferentes.

— Sriotchilism O'Zaic

1

@obarakon Também não é enganador desta questão , pois não é um código de golfe.

— Esolanging Fruit

2

Relacionado

— Sriotchilism O'Zaic,

1

Não tenho certeza se ele se encaixa nesse desafio (e, mesmo que isso aconteça, teria uma pontuação terrível), mas para os interessados, aqui está como eu faria isso Java: defina um processador de anotações (trecho de ideone) que você usará quando invocar javaccom seu -processoropção. Faz a compilação de qualquer classe travar para sempre.

— Aaron

6

Pelas respostas que resultam no travamento do compilador: Para fins de folga, acho que você ainda deseja que demore o máximo de tempo possível para travar.

— GuitarPicker 16/02

16

Japonês , 2 bytes

`ÿ

Você pode testar isso on-line aqui , mas eu não o recomendaria, pois congelará seu navegador.

Explicação

Japt usa a biblioteca shoco para compactar seqüências de caracteres. Um backtick diz ao compilador para descompactar tudo até o próximo backtick ou o final do arquivo. Cada byte faz o seguinte:

00-7F são deixados intactos.
80-BFcada transformar em um par de duas letras minúsculas comum ( at, oo, th, etc.).
C0-DFcada um consome o próximo byte e se transforma em uma sequência comum de quatro letras .
E0-EFcada um consome os próximos três bytes e se transforma em uma sequência de oito letras "comum" (iniciando Whererere descendo a partir daí).
F0-F7 quebre o descompactador, embora ele ainda retorne tudo até o byte de quebra.
F8-FFfaça com que o descompressor entre em um loop infinito. Não sei por que, pois não estou muito familiarizado com o funcionamento interno da biblioteca shoco (e o código JavaScript é completamente ilegível ), mas é bastante útil nesse caso.

Eu não acredito que haja outra maneira de mexer com o compilador Japt, mas você nunca sabe ...

— ETHproductions
fonte

10

Como assim, é ilegível. Claramente, você simplesmente não está se esforçando o suficiente.

— 15167

Eu gostaria que houvesse um decompiler emscripten ...

— tbodt

58

TikZ (pdfTeX 3.14159265-2.6-1.40.17), 85 79 74 24 22 21 bytes

Vários bytes salvos graças ao wchargin

Um byte economizado graças a Chris H

\input tikz
\tikz\pic

Na verdade, eu encontrei esse por acidente quando estava trabalhando na lição de casa. Passei um bom tempo esperando compilar antes de perceber o que estava acontecendo.

Isso tem duas partes:

\input tikz

Isso carrega o pacote TikZ

e:

\tikz\pic

Isso inicia um \tikzambiente e um comando de desenho.

O que está acontecendo

O compilador pdflatex tem problemas \tikz\pice entra no modo interativo, causando a interrupção indefinidamente.

— Sriotchilism O'Zaic
fonte

(1/2) Não consigo reproduzir isso. Recebo "Argumento fugitivo?! O \draw l\end {document}arquivo foi finalizado durante a verificação de uso de \tikz@next." pdflatex 3.1415926-2.5-1.40.14 (TeX Live 2013 / Debian). tikz 13/10/2010 v2.10. Isso é padrão apt install texlive-fullno Ubuntu 14.04.

— Wchargin #

1

@ wchargin Estou usando a mesma versão pdfTeX 3.14159265-2.6-1.40.17 (TeX Live 2016) e efetivamente faz um loop indefinidamente. Obrigado pelas dicas.

— Sriotchilism O'Zaic

1

Você pode salvar um byte usando \picem vez de \ draw` - exatamente o mesmo comportamento (testado usando TikZ 1.142)

— Chris H

3

Não acredito que estou defendendo não usar o TikZ, mas certamente o uso dele é um exagero aqui. O que há de errado com o antigo \def\a{\a}\a(12 bytes)? Ou, como esse é o código golf e ~está ativo por padrão \def~{~}~(9 bytes)?

— Loop Space

2

@LoopSpace Nada está errado com eles, eu simplesmente não sabia o que existia. Se você gostaria de fazer sua própria resposta, sinta-se à vontade.

— Sriotchilism O'Zaic

40

C, 18 bytes

#include __FILE__

Os compiladores geralmente desistem após repetir cerca de 200 vezes.

A construção do DOM conta como uma etapa de compilação? Se sim, então x.htm:

<iframe src=x.htm>

— Neil
fonte

14

Lembro-me de que conjuntos de quadros recursivos costumavam travar o IE4 com tanta força que às vezes derrubava componentes importantes do sistema operacional. Portanto, o HTML provavelmente conta.

10

@ ais523, porque, nos dias do IE4, o Internet Explorer era um "componente importante do SO".

— Mark

2

Um pouco de ajustes e é PHP válido: <?include __FILE__;.

— Ismael Miguel

6

Não é possível postar esta resposta porque meu representante não é alto o suficiente, mas duas alternativas são: #include "/ dev / zero" e #include "/ dev / stdin" - tenha cuidado ao executar a primeira !!

— Rruenza

2

Quando eu tentei, o uso da memória do gcc começou a crescer rapidamente sem limites, o sistema ficou sem resposta e meu cão de guarda finalmente entrou em ação e reiniciou. Foi bastante divertido :)

— rrauenza

38

Java, 102 95 89 88 78 bytes

class A<T>{}class B<T>extends A<A<?super B<B<T>>>>{A<?super B<A>>a=new B<>();}

Isso termina com o StackOverflowErrorque acontece porque o sistema de resolução genérico não pode decidir uma raiz na qual resolver os outros genéricos.

Créditos quando vencidos .

o que acontece aqui?

A<T>está lá apenas para ter um pai de uma letra. É genérico. Eu poderia ter usado List, mas as importações e a repetição de 4 letras são muito longas.
B<T> declara um genérico básico.
B extends Aé necessário ter uma hierarquia entre Be A.
extends A<A>cria uma auto-referência em A<T>.
A<? super B> aciona a pesquisa de genéricos em A<T>
B<B<T>>cria uma auto-referência em B<T>.
A<...> a=new B<>()força o uso dos genéricos, em vez de simplesmente defini-los, forçando a resolução ao compilar Be não posteriormente.
A<?super Bcria uma não referência própria, portanto, temos uma referência a um tipo e a outro nos genéricos de A.
B<A>cria uma não referência própria, portanto, temos uma referência a um tipo e a outro nos genéricos de B.

Agora, o tipo Atem o tipo genérico Ae B, mas qual deve ser escolhido? Esqueça a si mesmo, vamos tentar resolver B. Ping.

Ok, Btem o tipo de genéricos Ae B, mas qual deve ser escolhido? Esqueça a si mesmo, vamos tentar resolver A. Pong.

Este tipo de recursão não pode realmente ser evitada porque há casos legítimos como A<B<A<B<A<B<Object>>>>>>: por exemplo, um objeto JSON: List<Map<String,Map<String,List<Map<String,List<String>>>>>>.

Resultado da compilação

$ javac NoCompile.java


The system is out of resources.
Consult the following stack trace for details.
java.lang.StackOverflowError
        at com.sun.tools.javac.code.Types$UnaryVisitor.visit(Types.java:3260)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2587)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2579)
        at com.sun.tools.javac.code.Type$ClassType.accept(Type.java:554)
        at com.sun.tools.javac.code.Types$UnaryVisitor.visit(Types.java:3260)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2592)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2579)
        at com.sun.tools.javac.code.Type$ClassType.accept(Type.java:554)

No meu sistema, o rastreamento da pilha para depois de mostrar 1024 linhas, que são na verdade as 4 mesmas linhas repetidas 256 vezes, provando uma recursão infinita. Vou poupar todo esse vestígio.

Poupança

102 → 95 bytes: substituído interface+ implementspor class+ extends.
95 → 89 bytes: substituído Longpor A(duas vezes).
89 → 88 bytes: operador de diamante usado ( new B<A>()→ new B<>()).
88 → 78 bytes: moveu a declaração da variável para um membro da classe, graças a VoteToClose .

— Olivier Grégoire
fonte

1

O que eu estou olhando #

— Addison Crump

Você pode reduzi-lo para 78 bytes com:class A<T>{}class B<T>extends A<A<?super B<B<T>>>>{A<?super B<A>>b=new B<>();}

— Addison Crump

@VoteToClose Você está vendo um excelente exemplo de indecidibilidade nos genéricos de Java. Cada genérico deve ser resolvido com relação a uma raiz comum na qual é validada. A questão aqui é que o genérico de Bcontém uma referência indecidível ao genérico, o Aqual, por sua vez, contém uma referência indecidível ao genérico de B. Quando o resolvedor não pode decidir, ele verifica as referências incluídas, mas aqui os dois genéricos se referem um ao outro de forma undecidable (principalmente graças às referências auto ea superpalavra-chave para o resolvedor realmente ping-pongs entre os dois genéricos..

— Olivier Grégoire

Eu estava pensando em criar um problema em tempo de compilação com anotações cíclicas: public @interface X {@X(x=X.class)Class<? extends X> x();}... Mas rapidamente percebi por que isso não funcionaria lol.

— Magic Octopus Urn

34

Makefile GNU, 8 7 bytes

Um byte salvo graças ao KonradRudolph

Salvo como Makefilee invocado por make:

x:;make

Isso produzirá uma recursão infinita de compilação no primeiro destino encontrado "x".

Escusado será dizer que você realmente não deseja executar esta bomba de fork no seu servidor de produção. :-)

make
make[1]: Entering directory `/path/to/my/dir'
make
make[2]: Entering directory `/path/to/my/dir'
make
make[3]: Entering directory `/path/to/my/dir'
make
make[4]: Entering directory `/path/to/my/dir'
make
make[5]: Entering directory `/path/to/my/dir'
make
make[6]: Entering directory `/path/to/my/dir'
make
make[7]: Entering directory `/path/to/my/dir'
make
...

Versão alternativa, 5 bytes

Sugerida por KonradRudolph:

x:;$_

$_é uma referência ao último argumento do comando anterior. Mais especificamente, é resolvido aqui como o caminho absoluto para o comando que está sendo executado - que é o makepróprio.

Isso deve funcionar bem em um ambiente Bash genuíno, mas não no Windows + MinGW.

— Arnauld
fonte

2

Hmm, acho que makenão compila realmente o Makefile (apenas o interpreta).

— Zeppelin

3

@ zeppelin Você está certo, esta é provavelmente uma resposta limítrofe. Dito isso, os envios que envolviam recursão de macro no nível do pré-processador também nunca começarão a compilar nenhum código real.

— Arnauld

11

Ele se encaixa no objetivo pretendido: ter um processo de compilação infinito. +1!

— YSC 16/02

23

C ++, 60 58

template<class T>class a{a<T*>operator->();};a<int>i=i->b;

Isso cria recursivamente instâncias class acom diferentes parâmetros de modelo. O GCC 7.0 para após 900 níveis de recursão com muitos erros sobre operator->ser privado, mas, por exemplo, o ICC 17 e o Microsoft (R) C / C ++ Optimizing Compiler 19 atingem o limite de tempo .

O problema é que provavelmente todos os compiladores ficarão sem memória em algum momento, portanto, mesmo sem limites de recursão, isso será interrompido. O mesmo provavelmente se aplica à resposta Clojure também.

Edit: 2 bytes salvos por bolov - Obrigado

— Christoph
fonte

1

mais curto:a<int>i=i->b;

— bolov 16/02

1

@ Bolsos como afirmei na minha resposta, é porque o operator->padrão é privado dentro de uma classe. Dentro de uma estrutura é público e, portanto, i->bpode acessá-lo.

— Christoph

1

O gcc 4.4.7 parece travar indefinidamente aqui. Esperando o infinito ou mostrar a saída, o que ocorrer primeiro. Será atualizado

— osuka_

1

@osuka_ ainda está em execução?

— Christoph

1

@Christoph não, ele caiu com um SIGSEGV depois que eu o deixei funcionando por alguns dias. No entanto, esqueci de atualizar - obrigado pelo lembrete!

— osuka_

23

Perl , 15 13 bytes

BEGIN{{redo}}

Experimente online!

Agora, com 2 bytes salvos: @Zaid me lembrou de uma maneira terser de fazer um loop no Perl.

Isso é bem simples: ele instala apenas um gancho do analisador com um loop infinito, tornando o código demorado infinitamente para analisar. (O Perl é bom, pois permite executar código arbitrário no meio da análise; os ganchos do analisador são especificados no próprio Perl e costumam ser usados para fazer coisas como importar bibliotecas ou alterar as regras de análise para um identificador que você deseja tratar como uma palavra-chave.) O Experimente online! O link acima fornece a -copção (compilar o código para verificar se a sintaxe está correta, mas não executá-lo), para provar que o loop infinito acontece no momento da compilação.

Caso você esteja se perguntando sobre o "tempo de compilação" em uma linguagem de script: o Perl realmente compila no bytecode e depois executa o bytecode, mas esse é um detalhe que raramente é relevante na programação. A -MO=família de opções da linha de comando pode ser usada para executar outras ações com o bytecode (exceto com este programa, pois o loop infinito ocorre antes que o bytecode possa ser gerado).

1

a:goto aparece bom também (mesmo bytecount infelizmente).

— Dada

3

BEGIN{{redo}}irá economizar alguns bytes

— Zaid

20

C ++, 37. 30 29 bytes

int f(auto p){f(&p);},a=f(0);

Ele usa o futuro parâmetro de função automática. Foi proposto no C ++ 17, mas acho que não foi possível. gccno entanto, suporta isso como uma extensão.

Basicamente

void foo(auto p);

é equivalente a

template <class T>
void foo(T p);

O código tenta instanciar frecursivamente com diferentes argumentos de modelo. gccfalha com

erro fatal: a profundidade da instanciação do modelo excede o máximo de 900 (use -ftemplate-depth = para aumentar o máximo)

Com -ftemplate-depth=10000isso, cuspi "Tempo morto de processamento excedido" no godbolt.

Confira no godbolt

1 byte salvo por Quentin. Obrigado.

— Bolov
fonte

1

Um byte podem ser guardados, utilizando intcomo o tipo de retorno :)

— Quentin

De fato, os autoparâmetros de função não chegaram ao C ++ 17; e também int f() { ... }, a;não é uma declaração legal da última vez que verifiquei. (Você não pode misturar declarações de função com declarações de variáveis como essa.) O que você tem aqui é um dialeto C ++ extremamente específico para o GCC. Não que haja algo errado com isso neste contexto. :)

— Quuxplusone

19

Lisp comum, 8 bytes

#.(loop)

O compilador tentará ler um formulário e encontrará a macro do leitor de ponto sharpsign , que avalia o código no tempo de leitura e usa seu resultado como o formulário para compilar. Aqui, o código que está sendo executado é um loop infinito.

— coredump
fonte

17

TeX, 9 bytes

\def~{~}~

O TeX funciona expandindo macros. Na maioria das vezes, as macros do TeX (também chamadas de seqüências de controle ) são da forma, \namemas também é possível definir certos caracteres como macros, chamados de caracteres ativos . O caractere ~está ativo por padrão no TeX comum e, portanto, pode ser usado como um nome de macro sem declaração adicional. O \def~{~}descrito acima define ~para que ele se expanda para ~. Ou seja, sempre que o TeX o encontra ~, o substitui ~e reexamina a substituição, o que significa que encontra uma ocorrência totalmente nova ~e a substitui por ~. Isso define o loop infinito. Tudo o que é necessário é iniciar o loop e é isso que a final ~faz.

Adicionado na edição

Para fazer isso adequadamente compilado , chame como:

pdftex -ini "&pdftex \def~{~}~"

A -inibandeira diz que pdftexdeve compilar um novo arquivo de formato. Este é um conjunto de definições pré-compiladas que podem ser carregadas quando o TeX é posteriormente chamado para acelerar o processamento de um documento (o LaTeX2e é um exemplo disso). Eu acho que o &pdftexadiciona alguns bytes, levando o total para 17.

— Espaço em loop
fonte

Isso acontece no momento da compilação? A pergunta requer que o loop infinito ocorra durante a compilação, não durante a execução.

@ ais523 Não tinha pensado completamente sobre isso. Eu estava procurando a resposta do TikZ. Eu adicionei uma alternativa que é definitivamente compilada, às custas de mais alguns bytes.

— Loop Space

2

@ ais523: Como sempre, "compilar" e "correr" são dois lados da mesma moeda. Pessoalmente, penso no código-fonte TeX como "compilando" em documentos PDF (que são "executados" pela exibição), da mesma maneira que o código-fonte C ++ é "compilado" em arquivos .exe (que são então "executados" por corrida). Mas você também pode pensar no pdftexprograma como "interpretar" a entrada TeX para produzir um PDF como "saída" - da mesma maneira que o g++programa "interpreta" a entrada C ++ para produzir um arquivo .exe como "saída". ;)

— Quuxplusone 20/02

13

Haskell, 25 + 17 = 42 bytes

a= $(let a='a':a in[|a|])

Um metaprograma simples de Haskell que define um valor infinito e tenta calcular esse valor no tempo de compilação.

Chamar com ghc -XTemplateHaskell <file.hs>(+17 para o parâmetro para o compilador)

— user2407038
fonte

Não $(let a=a in a)funciona (para 32 bytes)?

— Ry-

1

Não! O GHC é inteligente demais. Qualquer loop infinito do formulário let a = a in aé reescrito para uma exceção, que simplesmente causa um erro do compilador em oposição a um loop infinito. (embora talvez isso iria funcionar com um compilador Haskell diferente, mas eu não tenho um na mão para tentar)

— user2407038

Funciona com runghc para mim, então eu diria que é válido. (Na verdade, ele funciona com ghc, também 8.0.1 aqui..)

— Ry-

Realmente? Também estou no ghc 8.0.1 - para mim Exception when trying to run compile-time code: <<loop>>, tanto no intérprete quanto na compilação ... tecnicamente, o código acima também morre com uma exceção, mas um estouro de pilha, o que é explicitamente permitido pela especificação - e se você tivesse memória infinita, ela realmente funcionaria para sempre. A <<loop>>exceção é acionada muito antes de minha máquina ficar sem memória.

— user2407038

12

gradle, 10 9 bytes

for(;;){}

com o código acima colocado em um build.gradlearquivo. Gradle usa o groovy como idioma de base, então estamos realmente falando sobre o groovy aqui, mas como a pergunta era sobre o tempo de construção, imaginei que o gradle seria mais apropriado.

A execução de qualquer comando gradle build com o código acima imprime a linha de status da compilação compatível com o chefe pontudo:

$ gradle tasks
> Configuring > 0/1 projects > root project

se você está buscando um aumento, adicione o -dsinalizador de depuração para:

$ gradle -d tasks
14:56:25.522 [INFO] [org.gradle.internal.nativeintegration.services.NativeServices] Initialized native services in: .gradle/native
14:56:25.757 [DEBUG] [org.gradle.launcher.daemon.client.DaemonClient] Executing build 84908c0d-f28d-4c57-be61-40eaf0025e16.1 in daemon client {pid=27884}
14:56:25.761 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface tun0
14:56:25.762 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a loopback interface? false
14:56:25.762 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a multicast interface? false
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x:x:x:x:x:x:%tun0
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x.x.x.x
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a loopback interface? false
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a multicast interface? true
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x:x:x:x:x:x:%eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x.x.x.x
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote multicast interface eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface lo
<snip>
14:57:07.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
> Configuring > 0/1 projects > root project

que, além de parecer impressionantemente complicado, também é atualizado com um novo conjunto de:

15:07:57.054 [DEBUG] [org.gradle.launcher.daemon.server.Daemon] DaemonExpirationPeriodicCheck running
15:07:57.054 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
15:07:57.054 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.

linhas de status a cada 10 segundos, fazendo com que pareça que a compilação está ocupada fazendo coisas importantes ... técnicas.

— Matias Bjarland
fonte

8

SWI-Prolog, 34 bytes

term_expansion(_,_):-repeat,1=0.

Explicação

term_expansion/2 é algo que é chamado automaticamente pelo compilador antes de realmente compilar o código para transformar alguns termos no código-fonte em outros termos.

Aqui, introduzimos uma nova regra para term_expansion/2:repeat,1=0. .

repeat/0 é um predicado que sempre tem êxito e fornece um número infinito de pontos de escolha.

1=0está tentando unificar 1com 0, que é sempre false. Isso fará com que o compilador retorne repeat(já que sempre fornece um ponto de opção) e tente 1=0novamente, etc.

— Fatalizar
fonte

Não funciona no GNU Prolog, então estou assumindo que isso seja específico da implementação. Você pode colocar o nome de um compilador no cabeçalho. (Estou assumindo o SWI Prolog.) #

@ ais523 Graças, não verificar em outros distribs, mas desde que o material compilador é geralmente muito específico, eu deveria ter conhecido melhor ...

— Fatalize

@ ais523 No entanto, de acordo com isso , você pode usar expand_term(como diz term_expansionnão pode ser usado como aqui no GNU Prolog). expand_termPorém, ele não funciona no SWI.

— Fatalize

7

GNU Make, 44

.PHONY:x
$(MAKEFILE_LIST):x;sleep 1;touch $@

Não posso reivindicar crédito por isso. É derivado do livro de Robert Mecklenburg, Gerenciando Projetos com o GNU Make: O Poder do GNU Make for Building Anything .

Quando o make executa esse makefile, ele vê que o makefile está desatualizado (porque o destino .PHONY está desatualizado, então ele executa o comando touch, que atualiza o carimbo de data / hora do makefile. Em seguida, o make re-lê o arquivo e descobre o makefile está desatualizado ... Bem, você entendeu.

Prefiro isso ao outro Faça a resposta porque não usa recursão. Na minha VM, a outra resposta do Make continua a bifurcar os processos e, com cerca de 7.000 de profundidade, a VM é interrompida sem resposta. No entanto, com esta resposta, é possível continuar indefinidamente sem consumir os recursos do sistema. Você realmente será capaz de relaxar com essa compilação. Eu já fiz mais de 1.000.000 de iterações sem degradação aparente do sistema.

Observe que eu precisei adicionar o sleep 1para que o timestamp do makefile seja realmente atualizado sempre. Você pode alterar isso para sleep 0.01se desejar gravar as iterações um pouco mais rápido.

— Digital Trauma
fonte

6

GNU adiante, 15 bytes

Golfe

: : [do] [loop]

Redefine (recompila) a palavra :e chama um loop infinito imediato [do] [loop]dentro da nova definição (logo no momento da compilação).

Uma categoria de palavras não é compilada. Essas chamadas palavras imediatas são executadas (executadas agora), independentemente de o interpretador de texto estar interpretando ou compilando.

Experimente Online!

— zepelim
fonte

5

Clojure, 21 bytes

(defmacro a[]`(a))(a)

Vincula o compilador, definindo uma macro que emite repetidamente chamadas para si mesma.

No meu telefone, isso faz com que o REPL desligue e atrase o dispositivo. No meu laptop, isso falha totalmente com um StackOverflow.

Infelizmente, o StackOverflow acontece instantaneamente, mas ainda é válido de acordo com as regras.

— Carcinigenicado
fonte

5

MSBuild, 130 bytes

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <Target Name="X">
        <Exec Command="msbuild"/>
    </Target>
</Project>

Salve isso como um arquivo com .projextensão e execute msbuildno prompt de comando. O MSBuild executará seu único destino, o que simplesmente gera outro msbuildprocesso.

— Danko Durbić
fonte

O recuo é necessário para que isso funcione? E as novas linhas? Normalmente, é possível jogar fora do espaço em branco.

Não, é apenas mais fácil de ler. A contagem de caracteres não inclui espaços em branco.

— Danko Durbić 16/02

1

Ah, certo. Nesse caso, você provavelmente deve mencionar isso no corpo do post.

5

C, 31 bytes

main[-1llu]={1};

Inspirado pelo Trauma Digital . Compile com a -mcmodel=mediumbandeira.

Boa sorte ao compilar isso, você precisará de 1,8 yottabytes de RAM e espaço em disco.

— MD XF
fonte

4

Mathematica 33 Bytes

Compile[{},Evaluate@While[True,]]

O código tentará avaliar simbolicamente o argumento antes da compilação, e o próprio argumento é um loop infinito. A função While possui um segundo argumento nulo, pois não é importante.

— Kelly Lowder
fonte

"antes da compilação" Sim ... não.

— CalculadoraFeline

Por favor, forneça um argumento válido. reference.wolfram.com/language/tutorial/…

— Kelly Lowder

A questão é: o loop acontece durante a Compilechamada ou antes dela?

— CalculadoraFeline

3

Haskell _{^{(GHC, sem Template Haskell ou regras de reescrita personalizadas)}} , 138

{-#LANGUAGE FlexibleContexts,UndecidableInstances#-}
data A x=A
class C y where y::y
instance C(A(A x))=>C(A x)where y=A
main|A<-y=pure()

Teoricamente, isso entra em um loop infinito da mesma maneira que a abordagem C ++ : o método polimórfico yé instanciado para tipos cada vez mais complicados. Na prática, o tamanho padrão da pilha alocada transborda rapidamente:

$ ghc-7.10 wtmpf-file14146.hs 
[1 of 1] Compiling Main             ( wtmpf-file14146.hs, wtmpf-file14146.o )

wtmpf-file14146.hs:5:9:
    Context reduction stack overflow; size = 101
    Use -fcontext-stack=N to increase stack size to N
      C (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A t0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    In a stmt of a pattern guard for
                   an equation for ‘main’:
      A <- y
    In an equation for ‘main’: main | A <- y = pure ()

Créditos a Luke Palmer .

— deixou de girar contra-relógio
fonte

1

Haskell (ghc), 32 + 2 = 34 bytes

{-#RULES""main=main#-}
main=main

corra com ghc -O <file>. Dispara uma regra de reescrita para a função principal que reescreve para a mesma coisa. O único recurso lamentável é que o ghc é inteligente o suficiente para detectar isso e parar após 100 iterações. Não conheço uma maneira fácil de desativar esse comportamento.

— Homem do programa
fonte

1

Boo, 25 bytes

macro l:
 x=0 while 1>0
l

Isso define uma macro, que é executada em tempo de compilação, que executa um loop infinito e, em seguida, chama a macro.

— Mason Wheeler
fonte

1

Ferrugem, 18 bytes

include!(file!());

Auto-inclusão clássica. A Rustc é irritantemente sã e, por padrão, será resgatada após 128 recursões, e se expandirá primeiro para que o crescimento exponencial também não funcione. O mesmo se aplica às soluções C e C ++.

— CensoredUsername
fonte

0

Fator , 29 16

<< [ t ] loop >>

A parte entre << >> é executada no momento da análise.

Quanto ao que [ t ] loop faz, eu vou deixar você adivinhar ...

Você pode colocá-lo no Listener como está ou adicioná-lo a qualquer arquivo de vocabulário ou script com as informações correspondentes.

— fede s.
fonte

0

PHP, 19 bytes

<?include __FILE__;

— MD XF
fonte

Código mais curto para folga legitimamente

Especificações

Japonês , 2 bytes

Explicação

TikZ (pdfTeX 3.14159265-2.6-1.40.17), 85 79 74 24 22 21 bytes

O que está acontecendo

C, 18 bytes

Java, 102 95 89 88 78 bytes

o que acontece aqui?

Resultado da compilação

Poupança

Makefile GNU, 8 7 bytes

Versão alternativa, 5 bytes

C ++, 60 58

Perl , 15 13 bytes

C ++, 37. 30 29 bytes

Lisp comum, 8 bytes

TeX, 9 bytes

Haskell, 25 + 17 = 42 bytes

gradle, 10 9 bytes

SWI-Prolog, 34 bytes

Explicação

GNU Make, 44

GNU adiante, 15 bytes

Clojure, 21 bytes

MSBuild, 130 bytes

C, 31 bytes

Mathematica 33 Bytes

Haskell (GHC, sem Template Haskell ou regras de reescrita personalizadas) , 138

Haskell (ghc), 32 + 2 = 34 bytes

Boo, 25 bytes

Ferrugem, 18 bytes

Fator , 29 16

PHP, 19 bytes

Haskell _{^{(GHC, sem Template Haskell ou regras de reescrita personalizadas)}} , 138