SCL vs. AWL

epy

Level-1
Beiträge
19
Reaktionspunkte
2
Zuviel Werbung?
-> Hier kostenlos registrieren
Hi,

ich habe den selben Baustein in AWL und in SCL erstellt.
Beide Funktionieren gleich.
Doch obwohl der SCL Baustein einen viel kürzeren Code als der AWL Baustein hat,
braucht dieser trotzdem doppelt soviel Speicher und ist zudem auch noch langsamer (höhere CPU Zykluszeit).

Woran liegt das ?
Ist es dann nicht besser nur in AWL zu Programmieren ?
Oder habe ich beim übersetzen was falsch gemacht ?

Vieleicht kann mir da jemand weiterhelfen.

Gruß
Epy
 

Anhänge

  • Störungen auswerten SCL.txt
    921 Bytes · Aufrufe: 85
  • Störungen auswerten AWL.txt
    5,8 KB · Aufrufe: 64
Du musst dir den Ergenbiscode
generiert vom SCL Übersetzer Version: SCLCOMP K05.03.05.00_01.03.00.01 release
anschauen.

Code:
      SET   
      SAVE  
      =     L      2.1
      L     0
      T     #Index
      L     #Anzahl_Stoerungs_DW
      L     1
      -I    
      SPO   I007
      SPA   I008
I007: CLR   
      =     L      2.1
I008: L     2
      *I    
      SPO   I009
      SPA   I00a
I009: CLR   
      =     L      2.1
I00a: L     0
      T     #Index
      TAK   
      T     LW     4
      TAK   
A7d0: L     #Index
      L     LW     4
      <=I   
      SPBN  A7d1
      L     #Index
      ITD   
      L     L#8
      *D    
      SPO   I00b
      SPA   I00c
I00b: CLR   
      =     L      2.1
I00c: AUF   #DB_Stoerung
      LAR1  
      L     DBW [AR1,P#0.0]
      L     W#16#0
      <>I   
      SPBN  A7d2
      SET   
      =     #Stoerung
A7d2: L     #Anzahl_Stoerungs_DW
      L     2
      *I    
      SPO   I00d
      SPA   I00e
I00d: CLR   
      =     L      2.1
I00e: L     #Index
      +I    
      SPO   I00f
      SPA   I010
I00f: CLR   
      =     L      2.1
I010: ITD   
      L     L#8
      *D    
      SPO   I011
      SPA   I012
I011: CLR   
      =     L      2.1
I012: L     #Index
      ITD   
      TAK   
      T     LD     6
      TAK   
      L     L#8
      *D    
      SPO   I013
      SPA   I014
I013: CLR   
      =     L      2.1
I014: AUF   #DB_Stoerung
      LAR1  
      L     DBW [AR1,P#0.0]
      L     W#16#FFFF
      XOW   
      LAR1  LD     6
      T     DBW [AR1,P#0.0]
      L     #Index
      L     2
      +I    
      SPO   I015
      SPA   I016
I015: CLR   
      =     L      2.1
I016: T     #Index
      SPA   A7d0
A7d1: CLR   
      U     #Stoerung_loeschen
      SPBN  A7d3
      L     0
      T     #Index
      L     #Anzahl_Stoerungs_DW
      L     1
      -I    
      SPO   I017
      SPA   I018
I017: CLR   
      =     L      2.1
I018: L     2
      *I    
      SPO   I019
      SPA   I01a
I019: CLR   
      =     L      2.1
I01a: L     0
      T     #Index
      TAK   
      T     LW     4
      TAK   
A7d4: L     #Index
      L     LW     4
      <=I   
      SPBN  A7d5
      L     #Index
      ITD   
      L     L#8
      *D    
      SPO   I01b
      SPA   I01c
I01b: CLR   
      =     L      2.1
I01c: L     W#16#0
      AUF   #DB_Stoerung
      TAK   
      LAR1  
      TAK   
      T     DBW [AR1,P#0.0]
      L     #Index
      L     2
      +I    
      SPO   I01d
      SPA   I01e
I01d: CLR   
      =     L      2.1
I01e: T     #Index
      SPA   A7d4
A7d5: CLR   
      =     #Stoerung
A7d3: CLR   
      U     L      2.1
      SAVE  
      BE

wieviel langsamer ist den die SCL-Variante?

Aber bitte alles BEOBACHTEN ausschalten!!!

Frank
 
Doch obwohl der SCL Baustein einen viel kürzeren Code als der AWL Baustein hat,...

er hat einen übersichtlicher dargestellten Code!

Ich habe es an anderer Stelle auch schon ähnlich geschrieben:

Nur bei S7 gibt es überhaupt die Möglichkeit, denn generierten
Code und die Codegröße überhaupt zu vergleichen. Das ist interessant
legitim und lehreich. Aber das über die "in AWL gewandelten Ergebinsse"
immer so ein Brimborium gemacht wird, ist mir schleierhaft.

Außer bei kleiner SPS-Gruken, wo es auf jede "ms" ankommt ist mir das
Aussehen des AWL-Zielcodes völlig egal, hautpsache er funktioniert.
Und pflegeleichter ist SCL allemal, aber das soll jeder selbst entscheiden.

Frank
 
Jetzt mal unabhängig von der Frage.

In der SCL-Quelle wird der Ausgang Stoerung nicht immer definiert.
Code:
FUNCTION FC75 : VOID
TITLE = 'Störungen auswerten'
VAR_INPUT
    DB_Stoerung : BLOCK_DB;
    Anzahl_Stoerungs_DW : INT; 
    Stoerung_loeschen : BOOL;
   END_VAR
VAR_OUTPUT
    Stoerung : BOOL;
END_VAR
VAR_TEMP
   Index : INT;
END_VAR
 
[COLOR=red]Stoerung := FALSE;  // Ausgangsvariable initialisieren[/COLOR]
// Abfrage ob Störungbit vorhaden
Index := 0;
    FOR Index := 0 TO ((Anzahl_Stoerungs_DW-1)*2) BY 2 DO
         IF DB_Stoerung.DW[Index] <> 0 THEN
            Stoerung := true;
         END_IF; 
      // Quittierbereich des DB´s invertiren          
      DB_Stoerung.DW[(Anzahl_Stoerungs_DW*2)+Index] := DB_Stoerung.DW[Index] XOR 16#FFFF;        
    END_FOR;
//Störmeldebits löschen 
    IF Stoerung_loeschen = True THEN
           Index := 0;
                 FOR Index := 0 TO (Anzahl_Stoerungs_DW-1)*2 BY 2 DO
                    DB_Stoerung.DW[Index]:= 0; 
                 END_FOR;
           Stoerung := False;
    END_IF;
  END_FUNCTION

In der AWL-Quelle wird lesend auf den Ausgang Stoerung zugegriffen.
Code:
FUNCTION "Störungen auswerten" : VOID
TITLE =STÖRUNGEN AUSWERTEN                                         
//###############################################################################
//#####                                                                     #####
//#####                        STÖRUNGEN AUSWERTEN                          #####
//#####                                                                     #####
//###############################################################################
//
//EINGANGSPARAMETER:
//==================
//  DB_Störungen        - Datenbaustein in dem die Störungsbits beschrieben werden
//  Störung_löschen     - Alle Störungen werden gelöscht                         
//  Anzahl_Störungs_DW  - Anzahl der Datenworte für Störungen      
//                      
//AUSGANGSPARAMETER:
//==================
//  Störung             - Störung im Datenbaustein gefunden 
//  
//WIRKUNGSWEISE :
//===============
//Es werden die einzelnen Bits auf 'true' in einem Datenbaustein überwacht. 
//Wurde mindestes ein Bit auf 'true' gesetzt so wird der Ausgang Störung gesetzt. 
//Mit dem Eingangsparameter 'STÖRUNG LÖSCHEN' werden alle Bits auf 'false' 
//gesetzt u7nd der Ausgangsparameter 'STÖRUNG' wird gelöscht.
//Es wird die Anzahl der Störungs Datenwörter überwacht. Im direkten Anschluss 
//muß sich der Quittierungsbereich mit der gleichen Anzahl Datenwörter befinden. 
//Die Bits des Quittierungsbereiches werden automatisch invertiert. 
// 
//z.B.: Datenbaustein für Störungen DB123 
//      Anzahl Störungs Datenwörter = 5
//      Länge des Datenbausteins = 20 
//
//DW 0: Störungen 1
//DW 2: Störungen 2
//DW 4: Störungen 3
//DW 6: Störungen 4
//DW 8: Störungen 5
//DW10: Quittierbereich Störungen 1
//DW12: Quittierbereich Störungen 2
//DW14: Quittierbereich Störungen 3
//DW16: Quittierbereich Störungen 4
//DW18: Quittierbereich Störungen 5 
VERSION : 0.1
VAR_INPUT
  DB_Stoerungen : BLOCK_DB ;    //Datenbaustein der ausgewertet wird
  Anzahl_Stoerungs_DW : INT ;   //Anzahl der Störungen in Datenworten
  Stoerung_loeschen : BOOL ;    //Taster Störung löschen
END_VAR
VAR_OUTPUT
  Stoerung : BOOL ;             //Störung vorhanden
END_VAR
VAR_TEMP
  Schleifenzaehler : WORD ; 
  DB_Register : WORD ; 
  AR1_Register : DWORD ; 
  AR2_Register : DWORD ; 
  Anzahl_Dword : INT ; 
  Word_vorhanden : BOOL ; 
END_VAR
BEGIN
NETWORK
TITLE =Register sichern
      L     DBNO;           //Aktuellen DB sichern
      T     #DB_Register; 
      TAR1  ;               //Adressregister 1 sichern
      T     #AR1_Register; 
      TAR2  ;               //Adressregister 2 sichern
      T     #AR2_Register; 
NETWORK
TITLE =Daten aufbereiten
      AUF   #DB_Stoerungen; //Datenbaustein aufschlagen
//Erstes Störungs-DW in Adressregister 1
      L     P#0.0; 
      LAR1  ; 
//Erstes Quittier-DW in Adressregister 2
      L     #Anzahl_Stoerungs_DW; 
      ITD   ; 
      SLD   4; 
      LAR2  ; 
//Anzahl Doppelworte berechnen
      L     #Anzahl_Stoerungs_DW; 
      SRW   1; 
      T     #Anzahl_Dword; 
//Anzahl Doppelworte ungleich  
      L     #Anzahl_Stoerungs_DW; 
      L     1; 
      UW    ; 
      L     1; 
      ==I   ; 
      =     #Word_vorhanden; 
//Schleifenzaehler initialisieren
      L     0; 
      T     #Schleifenzaehler; 
//Wenn Störung vorhanden zum Quittierbereich
  [COLOR=red]    U     #Stoerung;[/COLOR] [COLOR=red]// lesend auf Ausgang zugegriffen[/COLOR]
      U     #Stoerung_loeschen; 
      SPB   QUIT; 
NETWORK
TITLE =Schleife Störung auswerten und Quittierbereich Invertieren
      L     #Anzahl_Dword;      //Anzahl der Doppelworte
GO1:  T     #Schleifenzaehler;  //in Schleifenzähler laden 
      L     DBD [AR1,P#0.0];    //Lade aktuelles Störungs-DBD
      INVD  ;                   //Invertieren
      T     DBD [AR2,P#0.0];    //Transferiere ins Quitt-DBD
      L     DBD [AR1,P#0.0];    //Lade aktuelles Störungs-DBD
      L     L#0;                //Lade 0
      <>D   ;                   //wenn ungleich 
      S     #Stoerung;          //Setze Störung
      +AR1  P#4.0;              //Störungs-DBD um 4 Byte erhöhen
      +AR2  P#4.0;              //Quitt-DBD um 4 Byte erhöhen
      L     #Schleifenzaehler;  //Schleife fertig ?
      LOOP  GO1; 
      UN    #Word_vorhanden;    //Wenn kein Word vorhanden 
      SPB   ENDE;               //zum Ende springen 
      L     DBW [AR1,P#0.0];    //Lade aktuelles Störungs-DW
      INVI  ;                   //Invertieren
      T     DBW [AR2,P#0.0];    //Transferiere ins Quitt-DW
      L     DBW [AR1,P#0.0];    //Lade aktuelles Störungs-DW
      L     0;                  //Lade 0
      <>I   ;                   //wenn ungleich 
      S     #Stoerung;          //Setze Störung
      SPA   ENDE; 
NETWORK
TITLE =Störungen löschen
QUIT: L     #Anzahl_Dword;      //Anzahl der Doppelworte
GO2:  T     #Schleifenzaehler;  //in Schleifenzähler laden
      L     L#0;                //Lade 0
      T     DBD [AR1,P#0.0];    //Transferiere in Doppelwort 
      +AR1  P#4.0;              //Störungs-DBD um 4 Byte erhöhen
      L     #Schleifenzaehler;  //Schleife fertig ?
      LOOP  GO2; 
      SET   ; 
      R     #Stoerung;          //Störung rücksetzten
      UN    #Word_vorhanden;    //Wenn kein Word vorhanden 
      SPB   ENDE;               //zum Ende springen 
      L     0;                  //Lade 0
      T     DBW [AR1,P#0.0];    //Transferiere in Word   
NETWORK
TITLE =Register wiederherstellen
ENDE: AUF   DB [#DB_Register];  //Gesicherten DB wieder öffen
      L     #AR1_Register;      //Adressregister 1 wiederherstellen 
      LAR1  ; 
      L     #AR2_Register;      //Adressregister 2 wiederherstellen
      LAR2  ; 
      SET   ;                   //VKE = 1
      SAVE  ;                   //BIE = 1
END_FUNCTION

Funktioniert der Code in der Praxis?


Zur Frage:
Wenn du dir den vom SCL-Compiler generierten Code ansiehst, solltest du die unterschiede der beiden Varianten herausfinden.

Wieviel Zykluszeit verbrauchen denn beide Varianten?

Habe im Moment leider kein S7 zur Hand.


Gruß
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Wow...
Das mit der Zykluszeit mach ich morgen gleich.

Aber wie komm ich an den AWL Code nach dem SCL Übersetzen ?

Danke schon mal.

Trick 15,28:

FC75 z.B. nach FC76 kopieren (dadurch verliert der kopierte SCL Baustein die direkte SCL-kopplung) und dann öffen - wow - AWL!!!

Frank
 
Ich persönlich finde die Debatte SCL vs. AWL nicht sehr produktiv.
Was soll denn dabei herauskommen?
"Wir sind die Tollsten Programmierer?"
Das erinnert mich einwenig daran "Ich bin der bessere Broker und schlage den DAX" (3 Wochen)
Was ist mit mathematischen Formeln der z.B aus Physik und Verfahrenstechnik?
Möchtest Du das auch in AWL programmieren? (z.B einen Logarythmus?)
Oder möchest Du auch F-Systems in AWL?
Ich habe vor 30 Jahren noch 8080 Assembler und Maschinencode programmiert und bin dankbar dass ich heute suboptimale Werkzeuge und Softwarwgeneratoren habe.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Es ist mir fürchterlich peinlich aber nun mal passiert!
Ich habe es auch sofort bemerkt aber keine Ahnung wie man einen doppelten Post dann auch löschen kann!
Kannst DU das reparieren?(von der Reparatur)
Gruß

:cry:
 
Das können nur die Administratoren, siehe:
http://sps-forum.de/showthread.php?t=37144

Entweder eine PN (persönliche Nachricht) an einen von denen, oder einfach nur den Text von deinem doppelten Beitrag löschen und etwas Kurzes rein schreiben wie:
"Doppel Posting" oder so was in der Art.
Schaut dann auf jeden Fall schon mal besser aus. ;)
 
Ich persönlich finde die Debatte SCL vs. AWL nicht sehr produktiv.
Was soll denn dabei herauskommen?
"Wir sind die Tollsten Programmierer?"
Das erinnert mich einwenig daran "Ich bin der bessere Broker und schlage den DAX" (3 Wochen)
Was ist mit mathematischen Formeln z.B aus Physik und Verfahrenstechnik?
Möchtest Du das auch in AWL programmieren? (z.B einen Logarythmus?)
Oder möchest Du auch F-Systems in AWL?
Ich habe vor 30 Jahren noch 8080 Assembler und Maschinencode programmiert und bin dankbar dass ich heute suboptimale Werkzeuge und Softwarwgeneratoren habe.
... und ich dachte immer, "suboptimal" (neusprech) wäre "katastrophal" (altsprech).

Was soll also bei dieser Diskussion rauskommen? Klar kann nun jeder daherkommen und seine persönlichen Präferenzen kundtun. Selbstverständlich mit dem Verweis darauf, dass seine persönliche Vorgehensweise ihm schon seit Jahren Erfolg beschert.

Ich gehs mal sachlich an: aufgrund der vorhandenen Rechenkraft war ich seither gezwungen, in AWL zu koden. Nun besteht mit Aufkommen leistungsfähigerer CPUs für mich die Möglichkeit, Dinge, die ich seiter mit der 318er in AWL gelöst habe, nun statt dessen in SCL formulieren zu können.
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Hi,

wollte eigentlich nur wissen warum der SCL Code mehr Speicher braucht und langsamer ist.
Da ich zukünftig mehr Bausteine in SCL erstellen will und ich gerne weis was los ist. SCL ist halt in vielen Bereichen Effektiver.
Danke an alle die mir hier weiter geholfen haben.

Ich habe heute noch einen Test gemacht. Beide Bausteine SCL und AWL funktionieren absolut gleich.
Hier mal das Ergebnis, ist einfach mal Interessant.
Getestet auf einer CPU 315-2 PN/DP mit 1000 DW.

AWL-Baustein:
Arbeitsspeicher 196 Bytes
Zykluszeit: 11 ms

SCL-Baustein:
Arbeitsspeicher: 526 Bytes
Zykluszeit: 56 ms

Gruß
Epy
 

Anhänge

  • Störung_auswerten_SCL.txt
    923 Bytes · Aufrufe: 29
  • Störung_auswerten_AWL.txt
    4,5 KB · Aufrufe: 20
Ganz einfach wenn ich mir den SCL Code umgewandelt ansehe
Code:
 SET   
      SAVE  
      =     L      2.1
      L     0
      T     #Index
      L     #Anzahl_Stoerungs_DW
      L     1
      -I    
      SPO   I007
      SPA   I008
I007: CLR   
      =     L      2.1
I008: L     2
      *I    
      SPO   I009
      SPA   I00a
I009: CLR   
      =     L      2.1
I00a: L     0
      T     #Index
      TAK   
      T     LW     4
      TAK   
A7d0: L     #Index
      L     LW     4
      <=I   
      SPBN  A7d1
      L     #Index
      ITD   
      L     L#8
      *D    
      SPO   I00b
      SPA   I00c
I00b: CLR   
      =     L      2.1
I00c: AUF   #DB_Stoerung
      LAR1  
      L     DBW [AR1,P#0.0]
      L     W#16#0
      <>I   
      SPBN  A7d2
      SET   
      =     #Stoerung
A7d2: L     #Anzahl_Stoerungs_DW
      L     2
      *I    
      SPO   I00d
      SPA   I00e
I00d: CLR   
      =     L      2.1
I00e: L     #Index
      +I    
      SPO   I00f
      SPA   I010
I00f: CLR   
      =     L      2.1
I010: ITD   
      L     L#8
      *D    
      SPO   I011
      SPA   I012
I011: CLR   
      =     L      2.1
I012: L     #Index
      ITD   
      TAK   
      T     LD     6
      TAK   
      L     L#8
      *D    
      SPO   I013
      SPA   I014
I013: CLR   
      =     L      2.1
I014: AUF   #DB_Stoerung
      LAR1  
      L     DBW [AR1,P#0.0]
      L     W#16#FFFF
      XOW   
      LAR1  LD     6
      T     DBW [AR1,P#0.0]
      L     #Index
      L     2
      +I    
      SPO   I015
      SPA   I016
I015: CLR   
      =     L      2.1
I016: T     #Index
      SPA   A7d0
A7d1: CLR   
      U     #Stoerung_loeschen
      SPBN  A7d3
      L     0
      T     #Index
      L     #Anzahl_Stoerungs_DW
      L     1
      -I    
      SPO   I017
      SPA   I018
I017: CLR   
      =     L      2.1
I018: L     2
      *I    
      SPO   I019
      SPA   I01a
I019: CLR   
      =     L      2.1
I01a: L     0
      T     #Index
      TAK   
      T     LW     4
      TAK   
A7d4: L     #Index
      L     LW     4
      <=I   
      SPBN  A7d5
      L     #Index
      ITD   
      L     L#8
      *D    
      SPO   I01b
      SPA   I01c
I01b: CLR   
      =     L      2.1
I01c: L     W#16#0
      AUF   #DB_Stoerung
      TAK   
      LAR1  
      TAK   
      T     DBW [AR1,P#0.0]
      L     #Index
      L     2
      +I    
      SPO   I01d
      SPA   I01e
I01d: CLR   
      =     L      2.1
I01e: T     #Index
      SPA   A7d4
A7d5: CLR   
      =     #Stoerung
A7d3: CLR   
      U     L      2.1
      SAVE  
      BE
und den AWL code den du programmiert hast ist deiner kürzer. Kürzer=weniger Speicher=schneller
 
Zuviel Werbung?
-> Hier kostenlos registrieren
Ich habe heute noch einen Test gemacht. Beide Bausteine SCL und AWL funktionieren absolut gleich.
Hier mal das Ergebnis, ist einfach mal Interessant.
Getestet auf einer CPU 315-2 PN/DP mit 1000 DW.

AWL-Baustein:
Arbeitsspeicher 196 Bytes
Zykluszeit: 11 ms

SCL-Baustein:
Arbeitsspeicher: 526 Bytes
Zykluszeit: 56 ms

Funktionieren gleich, aber du hast dir auch alle Mühe gegeben durch maximale Blödheit den SCL-Code langsam zu machen. Oder was soll die dreimalige Berechnung der Schleifengrenzwerte mit Multiplikation und Addition? Wieso programmierst du das nicht auch so wie in AWL mit einem rücklaufenden Zähler?

Klar wird bei so trivialem Code das vom Compiler generierte AWL nie so kompakt wie handverlese AWL. Aber so ein bißchen nachdenken und den Compiler unterstützen kann man auch, vor allem weil der Siemens SCL-Compiler mit Optimierung nicht ganz viel am Hut hat muss man da noch mehr nachhelfen.
 
Funktionieren gleich, aber du hast dir auch alle Mühe gegeben durch maximale Blödheit den SCL-Code langsam zu machen.

Eine ausgewogene Wortwahl sollte selbst überstreßten Programmierern möglich sein. :rolleyes:


Oder was soll die dreimalige Berechnung der Schleifengrenzwerte mit Multiplikation und Addition? Wieso programmierst du das nicht auch so wie in AWL mit einem rücklaufenden Zähler?

Wenn ich AWL nehme, denke ich in AWL.
Wenn ich SCL nehme, denke ich in SCL.

Wenn ich SCL nehme, will ich ja gerade den PASCAL/MODULA-Stil haben.
Da ist ja gerade die bessere Lesbarkeit von Vorteil. Wenn ich jetzt ständig
darüber nachdenken müßte, wie das dann ich AWL aussehen könnte,
da könnte ich gleich AWL nehmen. Dehalb sollte man ja für die mickrigen
Steuerungsvarianten kein SCL/GRAPH/CFC-Monster programmieren.

Ich habe schon C++ Programme aus Verifikationsgründen Strukturgleich
in SCL umgesetzt, damit nachher der Codereview schneller und einfacher
geht (das war so vorgesehen und gewollt).
Da nimmt man natürlich eine S7-400 genauso wie man für CFC eine
S7-400 nehmen sollte.

Wie gesagt, wenns schnell gehen soll, dann muss man es eben im Maschinencode (AWL)
programmieren.

Frank
 
Wenn ich AWL nehme, denke ich in AWL.
Wenn ich SCL nehme, denke ich in SCL.

Der AWL-Code ist aber auch nicht von einem Anfänger geschrieben. Genauso lernt man eben mit der Zeit welcher SCL-Code sich effizient umsetzen lässt.
Und wenn ich in SCL denke, setzt doch nicht der Verstand bei dem Punkt aus das eine arithmetische Operation Zeit kostet!?

Bei C-Programmierung auf Mikrocontrollern gibt es von den Herstellern oftmals Dokumente, wie man in C programmieren sollte sodass dieser in effizienten Assembler übersetzt werden kann. Das sind ja nicht viele Dinge die man beachten muss, nachher geht es in Fleisch und Blut über, genauso wie AWL eben auch wenn man es jahrelang macht.
 
Danke für die Blumen...

Hallo Thomas V2.1,

ist ja wirklich ein sehr nettes Forum hier.*ROFL*
Ja habe bisher viel mehr in AWL als in SCL Programmiert.
Sehr nett das dir das aufgefallen ist.

:ROFLMAO: Und wenn der SCL Code wenigsten dazu taugt
das sich ein frustrierter schlecht gelaunter Programmierer auskotzen kann
hat es sich ja gelohnt. :ROFLMAO:

Mit freundlichen Grüßen
Epy
 
Zurück
Oben