GCC: Label ohne Sprung Fehler?

[Walter T. (nicolas)]

Hallo zusammen,

ich konnte heute (nach etlichem Suchen einen Fehler beim Build mit dem 
AVR-GCC 4.8.1/Atmel Studio 6.2 einkreisen. Und zwar war im Quelltext 
eine Funktion vorhanden, die durch großzügiges Auskommentieren noch 
effektiv folgenden Inhalt hatte:

uint_fast8_t foo(void)
{
    uint_fast8_t status = 0;

    error:
    return status;
}

Das Vorhandensein dieser Funktion führt zu einer Fehler 
"RUNCOMPILERTASK", leider auch völlig ohne Konsolenausgabe.

Jetzt stellt sich natürlich die Frage: Was ist hier eigentlich 
verbotenes passiert? Welche Regel verbietet das Label "error" an dieser 
Stelle?

Viele Grüße
W.T.

[Peter II (Gast)]

Walter T. schrieb:
> leider auch völlig ohne Konsolenausgabe.

sicher?


test.c: In function 'foo':
test.c:8:5: warning: label 'error' defined but not used [-Wunused-label]
     error:

[Klaus W. (mfgkw)]

Ja, das ist nur eine Warnung.
Und ein Label ohne Verwendung ist kein Fehler.

Wenn der avr-gcc wirklich drüber stolpert, ist es wohl wirklich mal ein 
Compilerfehler.

Ich habe es mit einem Linuc-gcc 4.8.4 probiert. Der gibt natürlich auch 
die Warnung aus, aber sonst klappt es.

[Walter T. (nicolas)]

Peter II schrieb:
> test.c:8:5: warning: label 'error' defined but not used [-Wunused-label]
>      error:

Diese Warnung ist selbstverständlich vorhanden. Aber der Fehler muß ja 
weitaus später stattfinden.

[Peter II (Gast)]

Klaus W. schrieb:
> Ja, das ist nur eine Warnung.

eventuell ist ja:

-Werror
Make all warnings into errors.

gesetzt.

[Walter T. (nicolas)]

Peter II schrieb:
> eventuell ist ja:  -Werror [...] gesetzt.

Nein, das ist nicht der Fall.

Hier ist ein kompilierbares Minimalbeispiel im Anhang.

[Markus F. (mfro)]

Ich würde mal das Label umbenennen. Möglicherweise ist bloss die IDE zu 
blöd, die Compilerausgaben richtig zu parsen und zu interpretieren.

[Walter T. (nicolas)]

Markus F. schrieb:
> Ich würde mal das Label umbenennen. Möglicherweise ist bloss die IDE zu
> blöd, die Compilerausgaben richtig zu parsen und zu interpretieren.

Tatsache! Wenn ich das label umbenenne, funktioniert der Build.

Danke für die Antwort!


So schnell vergeht der Tag, und wie schnell ist nichts gemacht :-)

[Jörg W. (dl8dtl) (Moderator)]

Walter T. schrieb:
> Tatsache! Wenn ich das label umbenenne, funktioniert der Build.

Das kommt davon, wenn die Leute IDEs bauen, die einfach nur nach
dem Wort "error" suchen.

Schreib' Atmel einen Bugreport.

[Joachim B. (jar)]

Walter T. schrieb:
> Tatsache! Wenn ich das label umbenenne, funktioniert der Build.

nun ja ein Label auch error zu nennen war keine gute Idee.

Ich tue mich ja auch immer schwer mit Namen, aber reservierte Namen 
meide ich wie die Pest.

[Jörg W. (dl8dtl) (Moderator)]

Joachim B. schrieb:

> nun ja ein Label auch error zu nennen war keine gute Idee.

Das ist völlig üblich.

int somefunc(someargs)
{
   blah;
   if (error condition)
     goto error;
   proceed;

   return 0; // success

error:
   do some cleanup;
   return -1; // failure
}

Wenn man davon ein paar Fehlerbedingungen hat, spart das einfach
ein immer tiefer schachtelndes (und dadürch völlig unübersichtlich
werdendes) if/else-Gerippe.

> Ich tue mich ja auch immer schwer mit Namen, aber reservierte Namen
> meide ich wie die Pest.

Wenn es ein reservierter Name ist, kann man ihn nicht benutzen,
aber "error" ist halt keiner.

[Joachim B. (jar)]

Jörg W. schrieb:
> Joachim B. schrieb:
>> Ich tue mich ja auch immer schwer mit Namen, aber reservierte Namen
>> meide ich wie die Pest.
>
> Wenn es ein reservierter Name ist, kann man ihn nicht benutzen,
> aber "error" ist halt keiner.

das sah der gcc oder Atmel wohl anders, aber lass uns darüber nicht 
streiten

[Markus F. (mfro)]

Joachim B. schrieb:
> das sah der gcc oder Atmel wohl anders, aber lass uns darüber nicht
> streiten

Das ist kein reservierter Name, das ist ein Programmierfehler in der 
IDE.

[Eric B. (beric)]

Jörg W. schrieb:
> Das ist völlig üblich.
> int somefunc(someargs)
> {
>    blah;
>    if (error condition)
>      goto error;
>    proceed;
>
>    return 0; // success
>
> error:
>    do some cleanup;
>    return -1; // failure
> }
>
> Wenn man davon ein paar Fehlerbedingungen hat, spart das einfach
> ein immer tiefer schachtelndes (und dadürch völlig unübersichtlich
> werdendes) if/else-Gerippe.

Hm? Dafür braucht man doch keine Verschachtelung?

int somefunc(someargs)
{
  int error = 0;

  // every called function returns 0 on OK, or a non-0 error code
  error = doSomething(someargs);
  if(!error)
  {
    error = doSomethingElse();
  }
  if(!error)
  { 
     error = doAnotherThing();
  }
  ...etc...

  // error handling
  if(error)
  {
     do_some_cleanup();
  }
  return error; 
}

Ein guter Compiler optimiert das schon :-)

[Joachim B. (jar)]

Markus F. schrieb:
> Das ist kein reservierter Name, das ist ein Programmierfehler in der
> IDE.

ist das nicht piepegal wenns nicht funzt?

was geht schneller?

Labelnamen ändern oder auf Bugbeseitigung hoffen?

[Jörg W. (dl8dtl) (Moderator)]

Eric B. schrieb:
> Dafür braucht man doch keine Verschachtelung?

Wenn man's so einfach ausdrücken kann, nicht.  Aber es gibt halt
Fälle, bei denen das sinnvoll ist.

Joachim B. schrieb:
>> Das ist kein reservierter Name, das ist ein Programmierfehler in der
>> IDE.
>
> ist das nicht piepegal wenns nicht funzt?

Nicht ganz.  Ein wenig Exaktheit ist auch für Ingenieure sinnvoll.

Ansonsten wäre es natürlich allemal sinnvoller, wenn Nicolas einfach
noch die Ursache der Warnung beseitigt. ;-)  Man #ifdef'ed auch den
Label selbst so, dass er bei der Kombination aus #ifdefs, die zum
leeren Funktionsrumpf geführt hat, gar nicht mehr erscheint.

[Markus F. (mfro)]

Joachim B. schrieb:
> ist das nicht piepegal wenns nicht funzt?

mir nicht. Ich will schon wissen, über wen ich mich aufrege ;)

[Walter T. (nicolas)]

Jörg W. schrieb:
> Ansonsten wäre es natürlich allemal sinnvoller, wenn Nicolas einfach
> noch die Ursache der Warnung beseitigt. ;-)  Man #ifdef'ed auch den
> Label selbst so, dass er bei der Kombination aus #ifdefs, die zum
> leeren Funktionsrumpf geführt hat, gar nicht mehr erscheint.

Man muß dazu sagen, daß dieses ganze Konstrukt während einer großen 
Veränderungs-Session entstanden ist: Viel auskommentiert, um es 
anschließend wieder neu zu schreiben.

Und wenn man gerade viel ändern muß, damit überhaupt wieder etwas geht, 
sucht man so einen Fehler sehr lange.

[Carl D. (jcw2)]

Markus F. schrieb:
> Joachim B. schrieb:
>> das sah der gcc oder Atmel wohl anders, aber lass uns darüber nicht
>> streiten
>
> Das ist kein reservierter Name, das ist ein Programmierfehler in der
> IDE.

Da scheint der Parser für die Compiler-Ausgabe nicht mit "error:" als 
validen Source-Code klar zu kommen. Wird "error" benutzt, gibt es diese 
Warnung nicht und somit taucht der Parserfehler nicht auf.
Wenn man genau hinschaut, dann fehlt die Positionsangabe vor "error:". 
Also ein Spar-Parser ;-)

[Joachim B. (jar)]

Carl D. schrieb:
> Also ein Spar-Parser ;-)

aus der Prüfentwicklung weiss ich das es fast unmöglich ist ALLE 
möglichen Fälle abzufangen.

Ich war immer wieder überrascht welche "Tastenkombinationen" das 
Prüffeldpersonal fand um mein Programm abstürzen zu lassen.

Wie sagte Cheffe mal: "manchmal muss man den Entwickler die Stücke aus 
der Hand reissen"

oder anders gesagt, ich könnte unendlich lange programmieren und immer 
noch unsichere Statements finden.

Ich weiss ja das mal alles auf Plausiblität prüfen müsste, aber wenn ich 
einen leeren String äh Array of char habe dann prüfe ich nicht ob das 
erste Zeichen 0 ist oder ob am Ende vom Array auch eine 0 steht.

[Jörg W. (dl8dtl) (Moderator)]

Joachim B. schrieb:
> aus der Prüfentwicklung weiss ich das es fast unmöglich ist ALLE
> möglichen Fälle abzufangen.

Nun, andere schaffen das bei GCC allerdings völlig problemlos.

foo.c:2:1: error: unknown type name 'doble'
 doble bar;
 ^
foo.c:1:12: warning: 'foo' defined but not used [-Wunused-variable]
 static int foo;
            ^

Es gibt also immer ein "error:" (oder "warning:") – das traf bei Nicolas
schon mal nicht zu (der Doppelpunkt fehlte); davor steht der Name der
Datei sowie Zeilen- und Spaltennummer.

Selbst, wenn der Name der Datei Leerzeichen enthält, kann man das
recht problemlos parsen.  Schwierig würde es natürlich, wenn die
Datei "foo.c:2:1: error:" heißt :-), aber sowas würde ein unter Windows
laufender Editor vermutlich ohnehin als Dateinamen ablehnen.

[Johann L. (gjlayde)]

Jörg W. schrieb:
> davor steht der Name der Datei sowie Zeilen- und Spaltennummer

Wobei die Spalte nur bei neueren Versionen angezeigt wird und dort per 
-fno-show-column deaktivierbar ist.

[Rolf Magnus (Gast)]

Jörg W. schrieb:
> Schwierig würde es natürlich, wenn die
> Datei "foo.c:2:1: error:" heißt :-), aber sowas würde ein unter Windows
> laufender Editor vermutlich ohnehin als Dateinamen ablehnen.

Sowas würde Windows selbst bereits als Dateinamen ablehnen.

[Max M. (stefan_b858)]

Eric B. schrieb:
> Jörg W. schrieb:
>> Das ist völlig üblich.
>> int somefunc(someargs)
>> {
>>    blah;
>>    if (error condition)
>>      goto error;
>>    proceed;
>>
>>    return 0; // success
>>
>> error:
>>    do some cleanup;
>>    return -1; // failure
>> }
>>
>> Wenn man davon ein paar Fehlerbedingungen hat, spart das einfach
>> ein immer tiefer schachtelndes (und dadürch völlig unübersichtlich
>> werdendes) if/else-Gerippe.
>
> Hm? Dafür braucht man doch keine Verschachtelung?
>
>

> int somefunc(someargs)
> {
>   int error = 0;
> 
>   // every called function returns 0 on OK, or a non-0 error code
>   error = doSomething(someargs);
>   if(!error)
>   {
>     error = doSomethingElse();
>   }
>   if(!error)
>   {
>      error = doAnotherThing();
>   }
>   ...etc...
> 
>   // error handling
>   if(error)
>   {
>      do_some_cleanup();
>   }
>   return error;
> }
>

> Ein guter Compiler optimiert das schon :-)

Es geht noch besser mit || chaining:

int somefunc(someargs)
{
    int result;
    if (funcA(..., &result)
        || funcB (...., &result)
        || funcC (...., &result))
            some_error_handling(...);
            return -1;
    if (funcD(..., &result)
        || funcE (...., &result)
        || funcF (...., &result)) {
            do_error_handling(...),
            return -1;
    }
    return 0; 
}

Dieses Pattern wird in Git häufig benutzt, gerade bei system calls.

[Kaj (Gast)]

Rolf Magnus schrieb:
> Jörg W. schrieb:
>> Schwierig würde es natürlich, wenn die
>> Datei "foo.c:2:1: error:" heißt :-), aber sowas würde ein unter Windows
>> laufender Editor vermutlich ohnehin als Dateinamen ablehnen.
>
> Sowas würde Windows selbst bereits als Dateinamen ablehnen.
Richtig, hauptsächlich wegen dem ':' -> Alternate Data Streams
https://de.wikipedia.org/wiki/Alternativer_Datenstrom#Beispiel

[Jörg W. (dl8dtl) (Moderator)]

Stefan B. schrieb:
> Dieses Pattern wird in Git häufig benutzt, gerade bei system calls.

Geht aber nur, wenn man zwischen den Aufrufen nichts weiter mit den
Daten machen muss.

Klar, es gibt meistens alternative Methoden, und jeder vernünftige
Programmierer wird das "goto error" wohl als letzte Variante in
Betracht ziehen.  Es ist aber müßig, nun alle anderen Optionen
auszukramen: es gibt halt Fälle, in denen sowas einfach mal die
Arbeit erleichtert (der Linux-Kernel mit seinen unzähligen "goto"s
wurde ja anderweitig schon mal zitiert).