Forum: PC-Programmierung Control Flow


von Armin S. (knall_e)


Lesenswert?

Hi!

Ich sitze derzeit an folgendem Problem:
Fuer Dokumentation von Sicherheitsrelevanter Software (ASIL) soll jede 
Funktion mit entsprechenden Ablaufkombinationen (je nach Parameter) 
beschrieben werden, damit diese im Anschluss anhand dieser Daten 
getestet werden kann. Soll heissen wenn ich eine Funktion habe die So 
aussieht (ch hoffe, ich mache gerade keinen Fehler):
1
void func()
2
{
3
    switch(haus.farbe)                          
4
    {
5
      case gelb:                    /* 1.1 */
6
        maler.streichen.gelb = TRUE;        
7
        if (haustier.vogel.ort == IM_KAEFIG      /* +1.1.1 */      
8
        {                                            
9
          haustier.katze.hunger == TRUE;          
10
        }                                            
11
        else                    /* 1.1.2 */    
12
        {                                            
13
          if (haustier.vogel.status == TOT)    /* +1.1.2.1 */    
14
          {                                        
15
            haustier.vogel.hunger == FALSE;        
16
          }                                        
17
          else                  /* +1.1.2.2 */    
18
          {                                        
19
            haustier.vogel.hunger == TRUE;     
20
          }                                        
21
        }                                            
22
        break;                                       
23
      case gruen:                    /* 1.2 */
24
        if ((haustier.katze.status == TOT) &&\    /* +1.2.1 */ 
25
        (oma.zuhause == TRUE))                       
26
        {                                            
27
          oma.gemuet = TRAURIG;               
28
        }                                            
29
        maler.streichen.gruen = TRUE;         
30
        break;                                 
31
      case blau:                    /* +1.3 */
32
        maler.streichen.blau = TRUE;        
33
        break;                                          
34
      default:                                            
35
        break;                                          
36
    }
37
  } 
38
}

Alle Kombinationen, die durchlaufen werden koennen, sind im Kommentar 
dahinter markiert. Diejenigen, mit + davor, sind tatsaechliche Aeste, in 
denen etwas getan wird.
Soll heissen ich moechte mir aus dieser Funktion die Daten wie z. B. 
1.2.4.3.1.2.3 und die darunterstehenden Aufrufe ansehen.
Warum das Ganze in einem Programm loesen?
Weil man sich hierbei sehr schnell vertut was die Aststruktur angeht - 
vorallem, wenn man eine dicke State-Machine hat, die recht viel 
abarbeitet.

Jetzt meine Frage: Kennt jemand zufaellig ein Programm die 
visualisierung (jeglicher Art) der Baumstruktur aller moeglichen 
Ablauefe einer Funktion realisiert?

Danke und Gruss,

Armin

von Eduard A. (Firma: e-jam GmbH) (aed)


Lesenswert?

Wie wäre es mit UML?

von Armin S. (knall_e)


Lesenswert?

Ich meinte eher ein Programm, das die Cases fuer mich aus der Funktion 
heraus erzeugt.

von Karl H. (kbuchegg)


Lesenswert?

Armin Sch. schrieb:
> Ich meinte eher ein Programm, das die Cases fuer mich aus der Funktion
> heraus erzeugt.

> Weil man sich hierbei sehr schnell vertut was die Aststruktur angeht - vorallem, 
wenn man eine dicke State-Machine hat, die recht viel abarbeitet.

So wie ich das sehe, ist der normale Weg, dass man zuvor seine 
Statemachine entwirft und dokumentiert und erst dann implementiert.
Dafür gibt es auch Werkzeuge.

Alles was in letzter Konsequenz mit 'reverse engeneering' zu tun hat, 
ist nun mal höllisch aufwändig. Dazu kommt, dass dafür der Markt nicht 
wirklcih gross genug ist, dass ich da eine Flut an Tools erwarten würde.

: Bearbeitet durch User
von Route_66 H. (route_66)


Lesenswert?

Armin Sch. schrieb:
> case gruen:                    /* 1.2 */
>         if ((haustier.katze.status == TOT) &&\    /* +1.2.1 */
>         (oma.zuhause == TRUE))
>         {
>           oma.gemuet = TRAURIG;

Du wirfst Zuweisungen und Vergleiche in Deinem "Quelltext" mächtig 
durcheinander. Das kann sehr fehlerträchtig werden!

: Bearbeitet durch User
von Prog R. (daniel_v)


Lesenswert?

Route 66 schrieb:
> Armin Sch. schrieb:
>> case gruen:                    /* 1.2 */
>>         if ((haustier.katze.status == TOT) &&\    /* +1.2.1 */
>>         (oma.zuhause == TRUE))
>>         {
>>           oma.gemuet = TRAURIG;
>
> Du wirfst Zuweisungen und Vergleiche in Deinem "Quelltext" mächtig
> durcheinander. Das kann sehr fehlerträchtig werden!


als allgemeinen Tipp hierfür (MISRA fordert das denke ich auch - und du 
bist ja im ASIL Bereich) kann ich dir empfehlen, das einfach so zu 
schreiben:
1
  if ((TOT == haustier.katze.status)

Wenn du die Konstanten links hältst, bekommst du sofort einen Fehler im 
Fall einer ungewollten Zuweisung.

von Karl H. (kbuchegg)


Lesenswert?

Prog Rammer schrieb:

> Wenn du die Konstanten links hältst, bekommst du sofort einen Fehler im
> Fall einer ungewollten Zuweisung.

Ich denke ganz ehrlich, dass es hier einfach besser ist, sich eine 
gewisse Sorgfalt anzugewöhnen. Denn das funktioniert dann auch beim 
Vergleich 2-er Variablen und nicht nur bei Konstanten. Die Schreibweise
1
   if( 5 == i )
ist mehr als ungewohnt. So funktioniert menschliches Denken im 
Normalfall nicht. Wir sagen nun mal nicht "Wenn es wahr ist, dass 5 
gleich der Anzahl der Milchtüten im Kühlschrank ist", sondern "Wenn die 
Anzahl der Milchtüten im Kühlschrank gleich 5 ist".
Ich gestehe zwar zu, dass da natürlich auch viel Gewohnheit dabei ist, 
aber im Regelfall ist man gut beraten nicht zu sehr zu künsteln und die 
gewohnten Denkmuster beizubehalten und die Dinge so zu formulieren, dass 
man nicht um die Ecke denken muss. Da kommt erfahrungsgemäss viel 
schneller Palawatsch raus, als wie wenn man am Anfang ganz einfach 
sorgfältig ist. Und mit ein bischen Übung ist ein Zuweisungs / 
Vergleichsfehler in C etwas, das nur gaaanz gaaaanz selten passiert. Und 
wenn, dann merkt man den sehr schnell.

: Bearbeitet durch User
von Prog R. (daniel_v)


Lesenswert?

Sehe ich, um ehrlich zu sein, auch so.
Aber andererseits hab ich's mir wegen MISRA (was wie gesagt auch hier 
relevant sein sollte) angewöhnen müssen und wenn man mal eine (gar nicht 
so lange) Weile seine Statements so formuliert, fällts gar nicht mehr 
auf.

von Eric B. (beric)


Lesenswert?

Armin Sch. schrieb:

> Jetzt meine Frage: Kennt jemand zufaellig ein Programm die
> visualisierung (jeglicher Art) der Baumstruktur aller moeglichen
> Ablauefe einer Funktion realisiert?

SourceInsight kann das zu einem gewissen Level -- ich habe selber aber 
noch nicht viel damit gearbeitet. Sonst gibt es Tools wie "Understand" 
von SciTools, oder "Structure 101" vom PRQA. Aber allen ko$tenpflichtig.

Nicht direkt zum Visualisieren, aber zum (automatischen) Testen von 
Software: VectorCast.

von Johannes R. B. (Gast)


Angehängte Dateien:

Lesenswert?

meinst du sowas hier?

... habe deinen Code mal in Sisy rein geworfen ;-)

Gruß J.

von Johann L. (gjlayde) Benutzerseite


Lesenswert?

Karl Heinz schrieb:
>Die Schreibweise
>
1
>    if( 5 == i )
2
>
> ist mehr als ungewohnt.

Gewohnheit ist Gewohnheitssache.  Und so unüblich ist die Schreibweise 
auch nicht.

Ich hab mir diese Schreibweise inzwischen angewöhnt, und damit ist sie 
denn  nicht mehr ungewohnt :-)

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.