Aus '\n' wird '\0'

[Walter T. (nicolas)]

Hallo zusammen,
ich nutze gerade den ARM-GCC und habe folgende, wahnsinnig komplizierte 
Funktion:

void printme(void)
{
    printf("\fPWM test PC9\n");
    printf("PWM test PC9\n"); // |<-- der Ausdruck muss genauso bleiben.
}

Schaue ich mir die Zeichenkette im Binary an, steht da allerdings:

0000A7F0  00 00 00 00 0C 50 57 4D 20 74 65 73 74 20 50 43  .....PWM test PC
0000A800  39 00 00 00 50 57 4D 20 74 65 73 74 20 50 43 39  9...PWM test PC9

d.h. das Newline am Ende wird zu einem '\0' gemacht.

Deshalb meine an die Wissenden:

 - Handelt es sich um gewünschtes Verhalten (irgendeine schwierig zu 
findende Definition von printf) ?

 - Wie kann ich den Compiler dazu bringen, das zu machen, was ich bei 
obigem Quelltext naiv erwartet hätte? Der Umbruch muß im oberen String 
bleiben. Momentan behelfe ich mir mit:

    printf("\fPWM test PC9\n \b");
    printf("PWM test PC9\n");

Viele Grüße
W.T.

[Rufus Τ. F. (rufus)]

Der Compiler wird Deine printf -Aufrufe durch effektivere puts 
-Aufrufe ersetzen (denn Deine "Formatstrings" enthalten keine 
Formatanweisungen und Du übergibst auch keine auszugebenden Variablen) 
-- und puts hängt das abschließende \n selbst an. Also kann es in der 
Stringkonstante weggelassen werden.

[g457 (Gast)]

Hast Du puts() selbst implementiert? Falls ja isses kaputt, falls nein 
höchstwahrscheinlich auch :-)

[Jim M. (turboj)]

Walter Tarpan schrieb:
> - Handelt es sich um gewünschtes Verhalten

Ja. Denn das "printf" wird durch ein "puts" ersetzt, welches das \n 
automagisch anfügt. Das müsste bei GCC auch irgendwo so dokumentiert 
sein.

Walter Tarpan schrieb:
> Der Umbruch muß im oberen String
> bleiben.

Darf ich fragen: Wieso?

[hp-freund (Gast)]

Walter Tarpan schrieb:
> printf("PWM test PC9\n"); // |<-- der Ausdruck muss genauso bleiben.

char text[] = "PWM test PC9\n";
.
.
printf("%s",text);

Dann ist er in Silizium gebrannt ;-)

[Walter T. (nicolas)]

Hallo zusammen,

Rufus Τ. Firefly schrieb:
> und puts hängt das abschließende \n selbst an.

danke für die Erinnerung! Das wird es sein.

g457 schrieb:
> Hast Du puts() selbst implementiert? Falls ja isses kaputt, falls nein
> höchstwahrscheinlich auch :-)

Ja, die Implementierung der stdio-Funktionen etwas kaputt. Nicht nur an 
dieser Stelle. (z.B. spielt sie total verrückt, wenn eine Zeichenkette 
mit nur einem Zeichen mit printf ausgegeben wird oder das 
Leerzeichen-Flag zur Formatierung verwendet wird). Sie lag CooCox bei.

Und so sieht sie aus:

/**
 * @brief  Outputs a string on stdout.
 *
 * @param pStr  String to output. 
 */
signed int puts(const char *pStr)
{
    return fputs(pStr, stdout);
}


/**
 * @brief  Implementation of fputs using the DBGU as the standard output. Required
 *         for printf().
 *
 * @param pStr     String to write.
 * @param pStream  Output stream.
 *
 * @return  Number of characters written if successful, or -1 if the output
 *          stream is not stdout or stderr.
 */
signed int fputs(const char *pStr, FILE *pStream)
{
    signed int num = 0;

    while (*pStr != 0) {

        if (fputc(*pStr, pStream) == -1) {

            return -1;
        }
        num++;
        pStr++;
    }

    return num;
}

Dann werde ich mal puts oder fputs (muß mal nachsehen, wer das 
Leerzeichen normalerweise erzeugt) entsprechend ergänzen. Danke fürs 
Lesen und die Ratschläge.

W.T.

[Walter T. (nicolas)]

hp-freund schrieb:
> Walter Tarpan schrieb:
>> printf("PWM test PC9\n"); // |<-- der Ausdruck muss genauso bleiben.
>
>
>

> char text[] = "PWM test PC9\n";
> .
> .
> printf("%s",text);
>

>
> Dann ist er in Silizium gebrannt ;-)

Genau. Ich hatte nur, um das Beispiel kürzer zu gestalten die zweite 
Zeile zu dem geändert, was oben im Post steht.

[Walter T. (nicolas)]

Und der Nachtrag: Hab's gefunden. fputs gibt kein Newline aus, aber 
puts. Das läßt sich ja dann leicht implementieren.

[Falk B. (falk)]

@ Walter Tarpan (nicolas)

>{
>    printf("\fPWM test PC9\n");
>    printf("PWM test PC9\n"); // |<-- der Ausdruck muss genauso bleiben.
>}

>0000A7F0  00 00 00 00 0C 50 57 4D 20 74 65 73 74 20 50 43  .....PWM test PC
>0000A800  39 00 00 00 50 57 4D 20 74 65 73 74 20 50 43 39  9...PWM test PC9

>d.h. das Newline am Ende wird zu einem '\0' gemacht.

Dann ist printf() ein Makro, das einen String vor dem echten Compilieren 
konvertiert und das \n entfernt. Ein normaler Compiler schmeißt das \n 
nicht raus.

[F. F. (foldi)]

Mal eine blöde Frage zu den Optimierungsmöglichkeiten eines Compilers.
Wenn man grundsätzlich eine Optimierung möchte, aber an bestimmten 
Punkten nicht, kann man das ins Programm schreiben, bzw. gibt es ein 
Möglichkeit dem Compiler das mitzuteilen, so wie bei sei () und cli () 
für die Interrupts?

[Stephan (Gast)]

hier 2 Beispiele:

#pragma GCC push_options
#pragma GCC optimize ("O0")

your code

#pragma GCC pop_options

und

void __attribute__((optimize("O0"))) foo(unsigned char data) {
    // unmodifiable compiler code
}

gefunden bei:
http://stackoverflow.com/questions/2219829/how-to-prevent-gcc-optimizing-some-statements-in-c

[hp-freund (Gast)]

Nicht selbst getestet:

http://stackoverflow.com/questions/5580140/is-there-a-way-to-tell-gcc-not-to-optimise-a-particular-piece-of-code

[F. F. (foldi)]

Toll, vielen Dank!

[Yalu X. (yalu) (Moderator)]

Falk Brunner schrieb:
> Dann ist printf() ein Makro, das einen String vor dem echten Compilieren
> konvertiert und das \n entfernt.

Genauer gesagt, ist es eine eine Built-In-Funktion des GCC. Solche
Built-In-Versionen gibt es auch für viele andere Funktionen aus der
Standardbibliothek und sind eigentlich eine feine Sache, da sie dem
Compiler Optimierungsmöglichkeiten eröffnen, die er ohne sie nicht 
hätte.

Sollten sie doch einmal stören, lassen sie sich mit -fno-builtin oder
-fno-builtin-<funktionsname> abschalten.

> Ein normaler Compiler schmeißt das \n nicht raus.

Was ist heutzutage noch normal? ;-)

[Falk B. (falk)]

@ Yalu X. (yalu) (Moderator)

>> Dann ist printf() ein Makro, das einen String vor dem echten Compilieren
>> konvertiert und das \n entfernt.

>Genauer gesagt, ist es eine eine Built-In-Funktion des GCC.

Aber das normale printf() im avr gcc schmeißt das \n doch nicht raus, 
oder?

[Yalu X. (yalu) (Moderator)]

Das \n wird nur dann hinausgeschmissen, wenn der Compiler den printf-
durch einen puts-Aufruf ersetzt, da puts im Gegensatz zu printf die
Ausgabe schon von sich aus mit einem \n abschließt. Am Verhalten des
Programms ändert sich dadurch überhaupt nichts.

Anderes Beispiel:

  printf("X");

wird vom GCC in

  putchar('X');

umgesetzt.

In diesem Fall fällt sogar die komplette Stringkonstante weg,
stattdessen wird der Zeichencode von 'X' direkt als Argument übergeben.