Schreiben Sie das kürzeste Programm, das die meisten Compiler-Warnungen und -Fehler generiert

42

Die Herausforderung:

Schreiben Sie ein sehr kurzes Programm, das beim Kompilieren die meisten Compiler-Warnungen und -Fehler erzeugt. Es kann in jeder Programmiersprache geschrieben werden.

Wertung:

Die Partitur ist durch diese Gleichung bestimmt: errors_and_warnings_length/code_length. Höchste Punktzahl gewinnt.

Beispiel:

Das C # -Programm classist 5 Zeichen lang und generiert 3 Warnungen, was einer Punktzahl von (1/5) * 3 = 0,6 entspricht.

BEARBEITEN:

Aus Unklarheiten müssen Programme mindestens 1 Zeichen lang sein. Andernfalls würde es eine Punktzahl von unendlich bekommen.

MD XF
quelle
17
Obwohl mir das Konzept gefällt, finde ich die Metrik etwas besorgniserregend. Welcher Compiler? Welche Einstellungen (insbesondere in Bezug auf Warnungen)? Ich meine, gcc -Wall -pedanticist sehr verschieden von plain ol` gccunterscheidet tccsich vermutlich von einem anderen c-Compiler.
dmckee
2
Holen
2
Ich würde gerne Antworten in anderen Sprachen als C / C ++ sehen.
Ken Bloom
4
Ich hätte es gern gesehen, wenn die Herausforderung darin bestanden hätte, so viele verschiedene Fehler wie möglich zu generieren
Hannesh
3
Hm. Andernfalls wäre die Punktzahl undefiniert .
wizzwizz4

Antworten:

94

GCC, score 2 200 / über 36 ≈ 4,5 × 10 58

#include __FILE__
#include __FILE__

Ich habe diesen Code noch nicht fertig kompiliert, aber basierend auf Tests und einfacher Mathematik sollte er insgesamt 2 200 #include nested too deeply Fehler erzeugen .

Natürlich ist das Programm einfach erweiterbar. Eine dritte Linie Hinzufügen bringt die Gäste bis zu 3 200 /54 ≈ 4,9 × 10 93 . Vier Linien geben 4 200 / über 72 ≈ 3,6 x 10 118 , und so weiter.

Ilmari Karonen
quelle
6
Sehr kluge Antwort. +1
Prince John Wesley
5
Sehr klug stimme ich zu, aber ich würde das als 1 Fehler zählen ("zu tief verschachtelt"), kein separater Fehler für jede Zeile der Rückverfolgung.
Kevin
1
@ Kevin: Nur um klar zu sein, sollte es diesen Fehler 2²⁰⁰ mal erzeugen, einmal für jeden möglichen Pfad, durch den die Verschachtelungsgrenze erreicht werden kann. Die Tatsache, dass jeder Fehler auch 200 Zeilen Backtrace enthält, macht die Ausgabe nur noch ausführlicher.
Ilmari Karonen
1
Hmm. Ich könnte schwören, als ich es letzte Nacht ausprobiert habe, dass GCC nach einem Fehler aus dem Verkehr gezogen ist, aber es scheint jetzt mehr zu drucken. Einspruch zurückgenommen. Übrigens ist 200 aus dem c-Standard?
Kevin
1
@Kevin Per gcc.gnu.org/onlinedocs/gcc-4.8.2/cpp/Implementation-limits.html : "Wir legen ein willkürliches Limit von 200 [verschachtelten #include] Ebenen fest, um eine außer Kontrolle geratene Rekursion zu vermeiden. Der Standard erfordert mindestens 15 Ebenen. "
zwol
48

C, 0 Zeichen - Punktzahl = (1/0) * 1 = Unendlich



erzeugt 1 Fehler:

/usr/lib/gcc/i686-pc-linux-gnu/4.7.0/../../../crt1.o: In function `_start':
(.text+0x18): undefined reference to `main'
collect2: error: ld returned 1 exit status

Hinweis: http://ideone.com/xdoJyA

l0n3sh4rk
quelle
49
1/0 ist undefiniert, nicht "unendlich".
Frank
3
+1 Auch wenn 1/0 undefiniert ist, ist es nachweislich größer als eins geteilt durch eine beliebige größere Zahl. 0 nimmt den Kuchen.
12.
6
@ jnm2 da bin ich mir nicht sicher. 1/0 ist undefiniert, und obwohl sich die rechte Seite der Unendlichkeit nähert, macht dies 1/0 überhaupt nicht definiert.
12.
5
Da die Domain positiv ist, halte ich das, was ich gesagt habe, für sinnvoll. Theorie macht Spaß, aber ich denke, wir brauchen hier einen gesunden Menschenverstand. Denken Sie daran, dass die meisten Compilerfehler für die geringste Codemenge auftreten. Die Grenze liegt auf der Hand.
12.
15
1.0 / 0.0 = + INF, zumindest nach IEEE 754 :) Sie müssen also nur die Berechnung im Gleitkomma durchführen.
Keith Randall
19

GCC, Punktzahl 5586.6 (und mehr, falls erforderlich)

179 Zeichen, 1000003 Warnungen / Fehler (mit -Wall)

#define E a,a,a,a,a,a,a,a,a,a
#define D E,E,E,E,E,E,E,E,E,E
#define C D,D,D,D,D,D,D,D,D,D
#define B C,C,C,C,C,C,C,C,C,C
#define A B,B,B,B,B,B,B,B,B,B
_(){A,A,A,A,A,A,A,A,A,A}

Dies kann natürlich beliebig erweitert werden. Beispielsweise würde die Verwendung von 10 #defines anstelle von 5 und einer Länge von 20 "Anrufen" anstelle von 10 zu einer Punktzahl von etwa (20 ** 10) / (179 * 4) = 14301675977.65 führen (und die Ausführung würde einige Zeit in Anspruch nehmen ;)

schnaader
quelle
7
Mit #define X(A) A,A,A,A,A,A,Aund können X(X(X(X(X(X(A))))))Sie Code viel schneller duplizieren.
Ugoren
12

GCC zweimal, 86

22 Zeichen, 1898 Fehler + Warnungen auf meinem System.
Ich bin sicher, dass dieser Ansatz erheblich verbessert werden kann, indem längere Dateien mit kürzeren Namen ausgewählt werden.

#include</usr/bin/gcc>
ugoren
quelle
3
/usr/bin/gdbist deutlich größer (5,5M vs 760K), aber /vmlinuzbei 5,6M könnte Ihre beste Wahl sein.
wchargin
12

HQ9 ++, 1 (Limit von (n + 29) / n)

Das Folgende gibt die Warnung Warning: this is not a quinefür jedes Q im Code aus.

QQQQQ...Q
Warning: this is not a quine

Klein ist gut, oder? Hmm ...

boothby
quelle
FWIW, das ist ein Witz. Wenn das nicht offensichtlich wäre.
Stand
10

C, .727

11 Zeichen, 5 Fehler, 3 Warnungen, (1/11) * 8 = .727273

m(;){@,x}2

cc -g -Wall    er.c   -o er
er.c:1: error: expected declaration specifiers or '...' before ';' token
er.c:1: warning: return type defaults to 'int'
er.c: In function 'm':
er.c:1: error: stray '@' in program
er.c:1: error: expected expression before ',' token
er.c:1: error: 'x' undeclared (first use in this function)
er.c:1: error: (Each undeclared identifier is reported only once
er.c:1: error: for each function it appears in.)
er.c:1: warning: left-hand operand of comma expression has no effect
er.c:1: warning: control reaches end of non-void function
er.c: At top level:
er.c:1: error: expected identifier or '(' before numeric constant

Luser Droog
quelle
Ich zähle 5 Fehler plus 3 Warnungen
Kevin
Ich nehme an, du hast recht. Ich habe die Zeichenfolgen "error:" und "warning:" gezählt.
luser droog
5
Ich denke, Sie gewinnen, wenn wir nur verschiedene Fehler / Warnungen zählen.
Ugoren
Wenn -Werror in der Befehlszeile verwendet wird, werden Warnungen in Fehler umgewandelt. Und auch, welcher C-Compiler verwendet wird, wirkt sich auf die Anzahl der gemeldeten Fehler aus (oder wenn -Fehler verfügbar ist usw.). Man könnte argumentieren, die Befehlszeilenlänge für den Aufruf könnte als Teil der "Programm" -Länge gezählt werden ... und jeder Die Compilerversion auf jeder Plattform ist eine separate Kategorie. :-)
Dr. Rebmu
8

NASM, Punktzahl 63/40 * 2 ^ 32 ≈ 2.905 * 10 ^ 19

%rep 1<<32
%rep 1<<32
!
%endrep
%endrep

Gibt c.asm:3: error: label or instruction expected at start of line2 ^ 64-mal aus. Dies ist wiederum leicht auf viel größere Ausgänge erweiterbar.

Kopieren
quelle
2

C ++ 98 (211 Byte) g ++ - 5 (Ubuntu 5.2.1-23ubuntu1 ~ 12.04) 5.2.1 0151031

Ich wollte sehen, wie gut ich in C ++ ohne den Präprozessor überhaupt tun könnte. Dieses Programm erzeugt 2.139.390.572 Bytes an Ausgabe, von denen der größte Teil eine einzelne Fehlermeldung ist.

template<int i,class S,class T>struct R{typedef R<i,typename R<i-1,S,S>::D,typename R<i-1,S,S>::D>D;};template<class S,class T>struct R<0,S,T>{typedef S D;};void f(){R<27,float,R<24,int*const*,int>::D>::D&E=4;}

me@Basement:~/src/junk$ ls -l a.C
-rw-rw-r-- 1 me me 211 Apr 27 21:44 a.C
me@Basement:~/src/junk$ g++-5 a.C -fmax-errors=1 2>a.C.errors.txt
me@Basement:~/src/junk$ ls -l a.C.errors.txt 
-rw-rw-r-- 1 me me 2139390572 Apr 27 22:01 a.C.errors.txt

Ungolfed:

template <int i, class S, class T>
struct R {
    typedef R<i, typename R<i-1,S,S>::D, typename R<i-1,S,S>::D> D;
};
template <class S, class T>
struct R<0, S, T> {
    typedef S D;
};
void f() {
    R<27, float, R<24, int*const*, int>::D>::D &E = 4;
}

Dieses Programm definiert eine rekursive Strukturvorlage R, die ein typedef D mit zwei Kopien von R enthält. Dies führt zu einem exponentiell wachsenden Typnamen, der in der Fehlermeldung vollständig ausgedruckt wird. Leider scheint g ++ zu ersticken, wenn versucht wird, eine Fehlermeldung zu drucken, die länger als (1 << 31) Byte ist. 2.139.390.572 Bytes waren das Maximum, das ich erreichen konnte, ohne es zu überschreiten. Ich bin neugierig, ob jemand die Rekursionsgrenzen und Parametertypen anpassen kann 27, float, 24, int*const*, um näher an die Grenze heranzukommen (oder einen Compiler finden kann, der eine noch längere Fehlermeldung ausgibt).

Auszüge aus der Fehlermeldung:

a.C: In function ‘void f()’:
a.C:1:208:  error:  invalid  initialization  of non-const reference of type
‘R<27, float, R<24, R<23, R<22, R<21, R<20, R<19, R<18, R<17, R<16, R<15,
R<14,  R<13, R<12, R<11, R<10, R<9, R<8, R<7, R<6, R<5, R<4, R<3, R<2, R<1,
int* const*, int* const*>, R<1, int* const*, int* const*> >, R<2, R<1, int*
const*,  int*  const*>,  R<1, int* const*, int* const*> > >, R<3, R<2, R<1,
int* const*, int* const*>, R<1, int* const*, int* const*> >, R<2, R<1, int*
const*,  int* const*>, R<1, int* const*, int* const*> > > >, R<4, R<3, R<2,
R<1, int* const*, int* const*>, R<1,
...
int*  const*,  int*  const*>  > > > > > > > > > > > > > > > > > > > > > > >
>::D& {aka R<27, R<26, R<25, R<24, R<23,  R<22,  R<21,  R<20,  R<19,  R<18,
R<17,  R<16,  R<15,  R<14, R<13, R<12, R<11, R<10, R<9, R<8, R<7, R<6, R<5,
R<4, R<3, R<2, R<1, float, float>, R<1, float, float> >, R<2,  R<1,  float,
float>,  R<1,  float, float> > >, R<3, R<2, R<1, float, float>, R<1, float,
float> >, R<2, R<1, float, float>, R<1, float, float> > > >, R<4, 
...
, R<1, float, float>, R<1, float, float> > >, R<3, R<2, R<1, float, float>,
R<1, float, float> >, R<2, R<1, float, float>, R<1, float, float> > > > > >
>  >  >  >  >  >  > > > > > > > > > > > > > > >&}’ from an rvalue of type
‘int’
    template<int    i,class   S,class   T>struct   R{typedef   R<i,typename
R<i-1,S,S>::D,typename  R<i-1,S,S>::D>D;};template<class  S,class  T>struct
R<0,S,T>{typedef                         S                         D;};void
f(){R<27,float,R<24,int*const*,int>::D>::D&E=4;}


                                                        ^
compilation terminated due to -fmax-errors=1.

2.139.390.572 Bytes / 211 Bytes = 10.139.291,8

Rechenmutter
quelle
Deshalb benutze ich immer STLfilt ... Willkommen bei PPCG! Dies ist eine großartige erste Einreichung!
Mego
1
Leider habe ich die Herausforderung missverstanden. Es sieht so aus, als würden Einsendungen nach der Anzahl der Fehlermeldungen bewertet, nicht nach der Anzahl der Bytes. Offensichtlich ist mein 1-Fehler-Eintrag nicht sehr wettbewerbsfähig. Vielleicht sollte meine Antwort hierher
Berechnung der Mutter
-1

SmileBASIC, 1/1 = 1

A

Erzeugt den Fehler Syntax Error in 0:1

12Me21
quelle
SB erzeugt immer nur einen Fehler auf einmal, daher ist dies wirklich die einzige Antwort, die Sie machen können.
snail_