Le défi:

Ecrivez un programme très court qui, une fois compilé, crée le plus grand nombre d’avertissements et d’erreurs du compilateur. Il peut être écrit dans n’importe quel langage de programmation.

Notation:

Le score est déterminé par cette équation: errors_and_warnings_length/code_length. Le score le plus élevé gagne.

Exemple:

Le programme C # class longueur de 5 caractères et génère 3 avertissements, soit un score de (1/5) * 3 = 0,6.

MODIFIER:

En raison d'une certaine confusion, les programmes doivent durer au moins 1 caractère. Sinon, cela donnerait un score d'infini.

GCC, partition 2 ²⁰⁰ /36 ≈ 4,5 × 10 ⁵⁸

#include __FILE__
#include __FILE__

Je n'ai pas encore fini de compiler ce code, mais d'après des tests et des calculs mathématiques simples, il devrait générer un total de 2 ²⁰⁰ #include nested too deeply erreurs.

Bien sûr, le programme est trivialement extensible. L' ajout d' une troisième ligne amène le score à 3 ²⁰⁰ /54 ≈ 4,9 × 10 ⁹³ . Quatre lignes donnent 4 ²⁰⁰ /72 ≈ 3,6 × 10 ¹¹⁸ , et ainsi de suite.

C, 0 caractères - Score = (1/0) * 1 = Infini

génère 1 erreur:

/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

Remarque: http://ideone.com/xdoJyA

GCC, score 5586.6 (et plus si nécessaire)

179 caractères, 1000003 avertissements / erreurs (utilisation -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}

Cela peut être étendu arbitrairement, bien sûr. Par exemple, utiliser 10 #defines au lieu de 5 et une longueur de 20 "appels" au lieu de 10 donnerait un score d'environ (20 ** 10) / (179 * 4) = 14301675977.65 (et prendrait un certain temps à courir ;)

GCC deux fois, 86

22 caractères, 1898 erreurs + avertissements sur mon système.
Je suis sûr que cette approche peut être grandement améliorée en choisissant des fichiers plus longs avec des noms plus courts.

#include</usr/bin/gcc>

HQ9 ++, 1 (limite de (n + 29) / n)

Ce qui suit émet l'avertissement Warning: this is not a quinepour chaque Q dans le code.

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

Petit c'est bien, non? Hmm ...

C, .727

11 caractères, 5 erreurs, 3 avertissements, (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

MSNA, score de 63/40 * 2 ^ 32 ≈ 2,905 * 10 ^ 19

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

Sortie c.asm:3: error: label or instruction expected at start of line2 ^ 64 fois. Encore une fois, ceci est facilement extensible à des sorties beaucoup plus grandes.

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

Je voulais voir comment je pouvais faire en C ++ sans utiliser le préprocesseur. Ce programme produit 2 139 390 572 octets de sortie, dont la plupart sont un seul message d'erreur.

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

Ce programme fonctionne en définissant un modèle de structure récursif R qui contient une typedef D contenant deux copies de R. Il en résulte un nom de type à croissance exponentielle, qui est imprimé intégralement dans le message d'erreur. Malheureusement, g ++ semble s’étouffer en essayant d’imprimer un message d’erreur de plus de (1 << 31) octets. 2 139 390 572 octets était le nombre le plus proche auquel je pouvais me rendre sans dépasser la limite. Je suis curieux de savoir si quelqu'un peut ajuster les limites de récursivité et les types de paramètres27, float, 24, int*const* pour se rapprocher de la limite (ou trouver un compilateur pouvant imprimer un message d'erreur encore plus long).

Extraits du message d'erreur:

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 592 octets / 211 octets = 10 139 291,8

SmileBASIC, 1/1 = 1

A

Génère l'erreur Syntax Error in 0:1