switch-case mit 4-Byte-Strings

[Johannes K. (joee)]

Hallo,

folgendes Problem:

uint32_t cmd;  //4 Bytes

cmd = LeseCmd(); //4 bytes

switch (cmd)
{
   case "ABCD"   //4 bytes, (ohne \0)
      ....;
}



Ich hätte hier gerne, dass beim kompilieren als Case-Vergleichswert der 
entsprechende ASCII-Code 12345678 benutzt wird, ohne dass ich diesen per 
Hand "ausrechnen" muss.

Für jeden dezenten Denkanstoß bin ich überaus dankbar.

PS:
'A' + ('B'<<8)+ ('C'<<16)+ ('D'<<24) geht, gefällt mir aber nicht.

[Rolle (Gast)]

Vieles was man gern hätte, muss man einfache selber machen !!!

Soooo geht das nicht !!!

[Rolle (Gast)]

Nein, jetz mal im Ernst:

Mir ist keine Präprozessor Anweisung bekannt die sowas leistet
und im case-Statement muss halt mal eine Konstante stehen

Aber machs halt so:

#define _ABCD    ('A' + ('B'<<8)+ ('C'<<16)+ ('D'<<24))
#define _ABC1    ('A' + ('B'<<8)+ ('C'<<16)+ ('1'<<24))
#define _ABC2    ('A' + ('B'<<8)+ ('C'<<16)+ ('2'<<24))
#define _ABC3    ('A' + ('B'<<8)+ ('C'<<16)+ ('3'<<24))
.
.
.


uint32_t cmd;  //4 Bytes

cmd = LeseCmd(); //4 bytes

switch (cmd)
{
   case _ABCD:        ....;
   case _ABC1:        ....;
   case _ABC2:        ....;
   case _ABC3:        ....;
      ....;
}

dann sieht dein Programm wenigstens schön aus


Viel Spass noch !!!

[Peter D. (peda)]

#define MK32(a,b,c,d) (((uint32_t)'a')<<24 | ((uint32_t)'b')<<16 | 'c'<<8 | 'd')
...
case MK32(A,B,C,D):

Peter

[DirkB (Gast)]

Versuch doch mal

int i = 'ABCD'; // einfaches Hochkomma

Der Compiler warnt zwar, aber gemacht hat er es.

[Werner B. (werner-b)]

Teste doch mal ob dein Compiler

  case 'ABCD':

verdaut. Mit einige Compilern funktioniert das. Es muss aber die 
Endianess beachtet werden. Dann muss mglw. mit

  case 'DCBA':

verglichen werden.

Edit:
Da war Dirk schneller ;-)

[Rolle (Gast)]

Peter Dannegger schrieb:
> #define MK32(a,b,c,d) (((uint32_t)'a')<<24 | ((uint32_t)'b')<<16 | 'c'<<8 | 'd')
> ...
> case MK32(A,B,C,D):


Das ist mal schnell schön hingeschrieben, geht aber nicht !!!

[Rolle (Gast)]

Rolle schrieb:
> Peter Dannegger schrieb:
>> #define MK32(a,b,c,d) (((uint32_t)'a')<<24 | ((uint32_t)'b')<<16 | 'c'<<8 | 
'd')
>> ...
>> case MK32(A,B,C,D):
>
>
> Das ist mal schnell schön hingeschrieben, geht aber nicht !!!
>
>
>
>     Beitrag melden | Bearbeiten | Löschen |

geht bei gcc, OK, aber nicht allen Compilern

[Falk B. (falk)]

@  Rolle (Gast)

>Das ist mal schnell schön hingeschrieben, geht aber nicht !!!

Weil der Peter ein paar Striche vergessen hat. So sollte es laufen.

#define MK32(a,b,c,d) (((uint32_t)'a')<<24 || ((uint32_t)'b')<<16 || 'c'<<8 || 'd')
...
case MK32(A,B,C,D):

MFG
Falk

[(prx) A. K. (prx)]

Falk Brunner schrieb:

> Weil der Peter ein paar Striche vergessen hat. So sollte es laufen.

= "case 1:"

[Michael R. (dj_motionx)]

#define MAKEK32(a,b,c,d) (((unsigned int)'a')<<24 || ((unsigned int)'b')<<16 || 'c'<<8 || 'd')

int main(void) {

  unsigned int  x;
  x = (((unsigned int)'X')<<24 || ((unsigned int)'Y')<<16 || 'Z'<<8 || 'A'); //Test
  switch (x) {

    case MAKE32(A,B,C,D):  printf("Falscher case");
                break;
    case MAKE32(X,Y,Z,A):  printf("Funktioniert");
                break;
    default:        break;
  }

  return EXIT_SUCCESS;
}

Funktioniert bei mir auch mit GCC nicht. Also ich glaube auch dass die 
Textersetzung mittels Makro nicht erlaubt ist und bei der case anweisung 
nur ganzzahlige Konstanten stehen dürfen.

-> Was spricht gegen einen if-Rechen


Mfg Michi

[Weissefaust (Gast)]

char string[5] = "abcd\0";

if(!strcmp(string, "ABCD")) {

} else if(!strcmp(string, "BCDA")) {

} else if(!strcmp(string, "DBCA")) {

} 
...
...

[Peter II (Gast)]

Michael Rathmair schrieb:
> Funktioniert bei mir auch mit GCC nicht.
geht nocht oder compiliert nicht? Wenn ja welche Fehlermeldung

> Also ich glaube auch dass die
> Textersetzung mittels Makro nicht erlaubt ist und bei der case anweisung
> nur ganzzahlige Konstanten stehen dürfen.
die Preprozessor ist es egal wo er etwas ersetzt, er kennt kein switch.
nach dem Preprozessor steht ja dort eine Konstante.

[(prx) A. K. (prx)]

Peter II schrieb:

> die Preprozessor ist es egal wo er etwas ersetzt,

Fast. Die Frage ist, ob er auch innerhalb von Strings ersetzt:

#define f(a) a 'a' "a"
f(x)

ergibt beim GNU CPP

x 'a' "a"

[Michael R. (dj_motionx)]

Oh sorry, sorry sorry für die Übereile.
Man sollte mal richtig tippen können.

Michael Rathmair schrieb:
> #define MAKEK32(a,b,c,d) (((unsigned int)'a')<<24 || ((unsigned int)'b')<<16 || 
'c'<<8 || 'd')

muss natürlich
#define MAKE32(a,b,c,d) (((unsigned int)'a')<<24 || ((unsigned 
int)'b')<<16 || 'c'<<8 || 'd')

sein.

#define MK32(a,b,c,d) (((unsigned int)'a')<<24 || ((unsigned int)'b')<<16 || 'c'<<8 || 'd')
...
unsigned int  x;
  x = (((unsigned int)'X')<<24 || ((unsigned int)'Y')<<16 || 'Z'<<8 || 'A'); //Test

  switch (x) {

    case MK32(A,B,C,D):  printf("Falscher case");
                break;
    case MK32(X,Y,Z,A):  printf("Funftioniert");
              break;
    default:        break;
  }

bringt trotzdem duplicate case value

Mfg

[(prx) A. K. (prx)]

Michael Rathmair schrieb:

> bringt trotzdem duplicate case value

Klar doch. (x || 'A') ist immer 1.

[Michael R. (dj_motionx)]

A. K. schrieb:
> Klar doch. (x || 'A') ist immer 1.

So gesehen schon dann funktioniert die Lösung aber doch nicht richtig 
?????

[(prx) A. K. (prx)]

Michael Rathmair schrieb:

> So gesehen schon dann funktioniert die Lösung aber doch nicht richtig

"||" ist ja auch Blödsinn.

Was geht:

define(`MK32',('$1'<<24|'$2'<<16|'$3'<<8|'$4'))
case MK32(a,b,c,d):

und das durch den M4 Präprozessor jagen. Gibt:

case ('a'<<24|'b'<<16|'c'<<8|'d'):

[Peter D. (peda)]

Rolle schrieb:
> Das ist mal schnell schön hingeschrieben, geht aber nicht !!!

Stimmt, die ' sind falsch, es geht nur so:

#define MK32(a,b,c,d) (((uint32_t)a)<<24 | ((uint32_t)b)<<16 | c<<8 | d)
...
case MK32('A','B','C','D'):

Peter

[ole (Gast)]

Michael Rathmair schrieb:
> -> Was spricht gegen einen if-Rechen
Beim einen werden Zahlen verarbeitet, beim anderen knechtet er mit 
Strings. Das ist beim PC relativ egal, ein posierlicher µC hat daran 
verdammt viel zu tun.
Egal ob PC oder nicht, solange es ohne String-geklöppel geht, würde ich 
es ohne machen.

Im übrigen sollte die Textersetzung der GCC gar nicht mitbekommen? Der 
Präprozessor kommt doch vor dem Compiler.

Michael Rathmair schrieb:
> A. K. schrieb:
>> Klar doch. (x || 'A') ist immer 1.
>
> So gesehen schon dann funktioniert die Lösung aber doch nicht richtig
> ?????
Wo ist denn der Unterschied zwischen '|' und '||'?
oder
Wo ist denn der Unterschied zwischen '&' und '&&'?

[U.R. Schmitt (Gast)]

Lest mal ein C Buch und findet heraus was der Unterschied zwischen einem 
'|' und einem '||' ist.
Ich würde im Zweifel aber auch die if then else if ... Kette bevorzugen.

[U.R. Schmitt (Gast)]

Uups A.K., Peter und ole waren schneller :-)

[Michael R. (dj_motionx)]

Peter Dannegger schrieb:
> Stimmt, die ' sind falsch, es geht nur so:#define MK32(a,b,c,d) 
(((uint32_t)a)<<24 | ((uint32_t)b)<<16 | c<<8 | d)
> ...
> case MK32('A','B','C','D'):

Das sieht gut aus !

ole schrieb:
> Wo ist denn der Unterschied zwischen '|' und '||'?
> oder
> Wo ist denn der Unterschied zwischen '&' und '&&'?

Oh je nochmal sorry. Klar weiß ich dass das '||' eine ein logische und 
das '|' eine bitweise Operation ist und in diesem Fall eine bitweise 
Operation richtig ist.

[U.R. Schmitt (Gast)]

Michael Rathmair schrieb:
> Oh je nochmal sorry. Klar weiß ich dass das '||' eine ein logische und
> das '|' eine bitweise Operation ist
Wobei du nicht der erste warst dem der Fehler passiert ist, das war wohl 
Falk, aber dem müssen wir nicht den Unterschied erklären :-)
Macht halt jeder mal einen Fehler, vor allem wenn man wie bei so Fragen 
mal schnell 'trocken' codiert, also ohne das dann zu compilieren 
und/oder auszuprobieren.

[Falk B. (falk)]

@  U.R. Schmitt (Gast)

>> Oh je nochmal sorry. Klar weiß ich dass das '||' eine ein logische und
>> das '|' eine bitweise Operation ist
>Wobei du nicht der erste warst dem der Fehler passiert ist, das war wohl
>Falk, aber dem müssen wir nicht den Unterschied erklären :-)

Ohhhh vor den kopfklatsch.

Da hatte ich wohl einen Dreher im Hirn. Und ich hab mich gestern ne 
halbe Stunde gefragt, warum bei meiner Simulation Unsinn rauskommt. 
Naja.

MFG
Falk

[Johannes K. (joee)]

Peter Dannegger schrieb:

 #define MK32(a,b,c,d) (((uint32_t)'a')<<24 | ((uint32_t)'b')<<16 |
 'c'<<8 | 'd')
 ...
 case MK32(A,B,C,D):

Das gefällt mir so ganz gut (natürlich inkl. Anführungszeichen an der 
richtigen Stelle ;-), aber mir ist noch etwas eingefallen:

Das ganze soll im Sinne von Modem-AT-Befehlen arbeiten. Wenn ich nun 
aber ca. 100 Befehle bearbeite, wird immer die komplette 4-Byte Variable 
verglichen. Ich weiß zwar nicht, was ein "if-Rechen" ist, aber ich 
glaube, dass damit ein Zweig im Sinne eines Stammbaumes gemeint ist. 
Jedenfalls führt letzteres zu einer enorm schnelleren Verarbeitung, da 
zB. viele Befehle mit 's' bzw. 'g' (set/get) beginnen:

switch (cmd>>24) {

    case 'A':  

        switch (cmd>>16) {

            case 'C':  printf("AC");
                        break;
            case 'D':  printf("AD");
                        break;
            default:   printf("Ax");
                        break;
          }

    case 'B':  

        switch (cmd>>16) {

            case 'C':  printf("BC");
                        break;
            case 'D':  printf("BD");
                        break;
            default:   printf("Bx");
                        break;
          }
    default:   printf("xx");
                break;
  }

Ich hatte gehofft, dass der super gcc auch dieses herausfindet und somit 
den ersten Buchstaben nur einmal vergleicht usw., tut er aber nicht. Es 
bleibt mir also wohl doch nur die Möglichkeit, die Befehle aufzudröseln.

Allen Beteiligten vielen Dank für die Anregungen.

[(prx) A. K. (prx)]

Johannes K. schrieb:

> Ich hatte gehofft, dass der super gcc auch dieses herausfindet und somit
> den ersten Buchstaben nur einmal vergleicht usw., tut er aber nicht. Es
> bleibt mir also wohl doch nur die Möglichkeit, die Befehle aufzudröseln.

Du kannst dir auch mal flex anschauen:
de.wikipedia.org/wiki/Lex_(Informatik)
en.wikipedia.org/wiki/Flex_lexical_analyser

[Stefan E. (sternst)]

Johannes K. schrieb:
> den ersten Buchstaben nur einmal vergleicht usw., tut er aber nicht.

Mir ist zwar nicht klar, was genau du damit meinst, aber bei deinem 
Beispiel fehlen
1) die breaks hinter den "Sub-Switches"
2) das Ausmaskieren eines Zeichens im switch ((cmd>>16) ist nicht das 
zweite Zeichen, sondern die ersten beiden)

Zusatz zu 2): wenn du jeweils nach einzelnen Buchstaben vorgehst, wozu 
dann diese vorher überhaupt zu einem uin32_t kombinieren?

[Johannes K. (joee)]

Stefan Ernst schrieb:

> Mir ist zwar nicht klar, was genau du damit meinst, aber bei deinem
> Beispiel fehlen
> 1) die breaks hinter den "Sub-Switches"

Da hast du natürlich Recht.

> 2) das Ausmaskieren eines Zeichens im switch ((cmd>>16) ist nicht das
> zweite Zeichen, sondern die ersten beiden)

Ich meine, dass er immer nur 1 Byte benutzt, da ich ja mit nur 1 
vergleiche. Daher verwendet der Compiler dann doch das zweite.

>
> Zusatz zu 2): wenn du jeweils nach einzelnen Buchstaben vorgehst, wozu
> dann diese vorher überhaupt zu einem uin32_t kombinieren?

Mache ich dann natürlich nicht, war jetzt im Beispiel einfacher.

[Stefan E. (sternst)]

Johannes K. schrieb:
> Ich meine, dass er immer nur 1 Byte benutzt, da ich ja mit nur 1
> vergleiche. Daher verwendet der Compiler dann doch das zweite.

Da meinst du falsch. Du vergleichst keine einzelnen Bytes, sondern 
komplette Zahlen.

uint16_t a = 0xabcd;
uint8_t b = 0xcd;

if (a==b) ...

Der Vergleich ist natürlich false, und nicht etwa (wie du meinst) true, 
nur weil der untere Teil von a mit b übereinstimmt.

[Johannes K. (joee)]

Stefan Ernst schrieb:
> Da meinst du falsch. Du vergleichst keine einzelnen Bytes, sondern
> komplette Zahlen.

Ok, hast natürlich wieder Recht. Ich würde also noch nach uint8_t casten 
müssen, wenn ich es so verwenden wollte. Richtig?

Meine Lösung sieht nun so aus (Auch, wenn mir Vergleiche mit "SE", "SD", 
usw. lieber gewesen wäre):

void ConfigCheckCommand()
{
    if (UART0_receive_line())
    {
        switch (uart0_rx[0])
        {
        case 'S':

            switch (uart0_rx[1])
            {
            case 'E':
                HMPowerOn();
                break;
            case 'D':
                HMPowerOff();
                break;
            case 'R':
                LampenEnable(&raumlicht, 1);
                break;
            case 'L':
                LampenEnable(&leselampe, 1);
                break;
            }

            break;

        case 'G':

            switch (uart0_rx[1])
            {
            case 'P':
                UART0TransmitByte(power_on);
                break;
            case 'R':
                UART0TransmitByte(LampenGet(&raumlicht));
                break;
            case 'L':
                UART0TransmitByte(LampenGet(&leselampe));
                break;
            }

            break;
        }
    }
}

[Johannes K. (joee)]

A. K. schrieb:
> Du kannst dir auch mal flex anschauen:
> de.wikipedia.org/wiki/Lex_(Informatik)
> en.wikipedia.org/wiki/Flex_lexical_analyser

Was willst du mir damit sagen?
Dass der GCC es doch erkennt und alle 'Axxx' zusammenfast und alle 
'Bxxx'?

[(prx) A. K. (prx)]

Johannes K. schrieb:

> Was willst du mir damit sagen?
> Dass der GCC es doch erkennt und alle 'Axxx' zusammenfast und alle
> 'Bxxx'?

Lex/Flex sind Codegeneratoren, denen man ein spezielle Quellfile 
vorsetzt und die daraus C Code produzieren. Das Ergebnis ist eine 
C-Funktion, die nicht mehr einzelne Zeichen zurück gibt, sondern fertige 
Tokens die für eine beliebige Anzahl Zeichen eines bestimmten Musters 
stehen. Und das recht zeiteffizient.

Aus der Lex-Beschreibung

"ABCD"  { return 1; }
"xyz"   { return 2; }
[0-9]+  { yylval = atoi(yytext); return 3; }
.       { crash("Trottel!"); }

wird Code erzeugt, der aus einem irgendwoher sequentiell gelesenen 
Zeichenstrom beim String "ABCD" den Wert 1 zurück gibt, bei "xyz" 2, bei 
jeder nicht negativen dezimalen Ganzzahl 3 (und deren Wert sich in der 
Variable yylval befindet). Die letzte Zeile ist sowas wie das default: 
vom switch.

Das sind gern benutze Tools, um Programmier- oder Kommandosprachen in 
ihre lexikalischen Einzelteile wie Schlüsselworte, Zahlen, Strings und 
Namen zu zerlegen.