Source Formatter, der folgendes kann gesucht

[RSE]

Hallo,

ich möchte gern einen Source Formatter einsetzen. Der in Delphi XE mitgelieferte hat allerdings keine weiteren Optionen zur Einrückung bei (weil länger 80 Zeichen) umgebrochenen Zeilen. Ich möchte, dass folgender Quellcode zumindest so bleibt, wenn der Formatter drübergeht:

Delphi-Quellcode:

if (MyIntegerVarWithVeryExtendedTooLongName = 
    MyOtherIntegerVarWithVeryExtendedTooLongName) and
   (SomeOtherVar > SomeIntegerVar) and
   ((IntVar > IntConst1) or
    (IntVar > IntConst2) or
    (IntVar > IntConst3) or
    (IntVar > IntConst4)) then
  AnweisungMitSehrLangemNamen(ArgumentMitSehrLangemNamen,
    ZweitesArgument);

Genauer gesagt steht in unserem Styleguide u.a. folgendes:

• Wird die Bedingung im Kopf einer Kontrollstruktur umgebrochen, so richtet sich die Einrückung der nächsten Zeile am Beginn der Bedingung aus
• Die Einrückung kann vergrößert werden, um die Lesbarkeit der Klammerung zu verbessern

Die Einrückung im Kopf einer IF-Struktur (nicht IF-Schleife) ist daher standardmäßig 3, ggf. plus Einrückung je nach Klammerung.

Gibt es Source Formatter, die so etwas zulassen können? Oder bei denen man das sogar als Formatierung so einstellen kann?

Edit: IF ist nun keine Schleife mehr. ;-)

[generic]

Damit man dich nicht hänselt zum Thema IF-Schleife:
Es gibt eine Internetwebseite, welche alles wichtige dazu zusammen fasst!
http://if-schleife.de/

[RSE]

Ich gebe dir allumfassend Recht! Wie ist der korrekte Oberbegriff für if, case, while, repeat, try etc.?

[DeddyH]

Kontrollstrukturen sollte es ganz gut treffen.

[RSE]

OK, damit wäre das geklärt. Zurück zur Frage im 1. Post ;-)

[Furtbichler]

Der Formatierer für diese Art von Code sitzt vor dem Rechner und muss nur Refactoring anwenden. Schreibe deinen Code einfach so, das er auf eine Zeile passt, wobei 'Zeile' durchaus 100-140 Zeichen umfassen darf.

Was ich damit sagen will: Gottseidank gibt es keine Formatierer, die grottenschlecht lesbaren Code so formatieren, das er ein wenig weniger grottenschlecht lesbar ist.

Wenn Du z.B. so eine komplexe Abfrage hast, dann packe sie in eine Funktion und nenn das Kind beim Namen.

Delphi-Quellcode:

if DieBedingungenSindAlleErfuellt then
  AnweisungMitSehrLangemNamen(ArgumentMitSehrLangemNamen,
    ZweitesArgument);

Aber ich merke gerade, das deine Frage eine ganz andere war :oops: (egal oben gesagtes musste ich einfach mal wieder loswerden).

Ich verwende DelForExp und dort gibt es die Markierungen '{(*}' und '{*)}' um Codestellen, die nicht formatiert werden sollen, so zu belassen. Das Teil kommt z.B. nicht mit 'class var' und Record-Methoden klar und dafür verwende ich es.

[RSE]

Kommentare zur Steuerung des Formatters lehne ich ab. Das möchte bitte alles so einstellbar sein, dass ich so etwas nicht brauche!

@Furtbichler:
Ich halte die Auslagerung von Quelltext in eigene Funktionen für kein geeignetes Mittel zur Strukturierung. Das führt lediglich dazu, dass ich ständig am Springen bin, wenn ich versuche später diesen Quelltext nachzuvollziehen und komplett zu verstehen (z.B. bei der Fehlersuche). Außerdem entstehen so unnötige Funktionsaufrufe. Und um dem gleich vorzubeugen: Ja, ich weiß von der inline-Möglichkeit und es macht bei den heutigen Prozessoren keinen großen Unterschied - außer es handelt sich um zeitkritische Routinen. Das vorher genannte reicht mir aber als Grund dagegen.

Eine Folge von Anweisungen sollte m.E. genau dann in eine Funktion ausgelagert werden, wenn sie an mehreren Stellen benötigt wird, also um Codedopplung zu vermeiden.

Sicherlich ist das auch Geschmackssache. Hier in der Firma sind wir allerdings alle der beschriebenen Meinung.

[Lemmy]

Zitat:

Zitat von RSE (Beitrag 1174886)

@Furtbichler:
Ich halte die Auslagerung von Quelltext in eigene Funktionen für kein geeignetes Mittel zur Strukturierung.

Du nicht, aber viele die sich mit Qualität von Sourcecode auseinander setzen schon. ;-)

Wenn ich versuche deinen Code oben zu verstehen, dann muss ich erst mal deine IF-Bedingungen KOMPLETT durchkauen und verstehen. Steht dagegen ein Funktionsaufruf, der einen korrekten Namen hat (d.h. der Name sagt wirklich das aus um was es geht), dann verstehe ich den Sinn innerhalb kürzester Zeit, weil die Komplexität der Bedingung erst mal vor mir verborgen wird. Wenn mich dann die Funktion interessiert habe ich zwar immer noch mit der komplexen Bedingung zu tun, aber dann halt NUR noch mit der Bedingung und nicht mehr mit dem was anschließend kommt.


Grüße

[Sir Rufo]

Und wenn schon anders formatiert, dann doch bitte so:

Delphi-Quellcode:

if 
  ( MyIntegerVarWithVeryExtendedTooLongName = 
    MyOtherIntegerVarWithVeryExtendedTooLongName )
and
  ( SomeOtherVar > SomeIntegerVar ) 
and
  (
    ( IntVar > IntConst1 ) 
  or
    ( IntVar > IntConst2 ) 
  or
    ( IntVar > IntConst3 ) 
  or
    ( IntVar > IntConst4 )
  ) 
then
  AnweisungMitSehrLangemNamen( 
    ArgumentMitSehrLangemNamen, 
    ZweitesArgument );

Das müsste man einem Formatierer sogar beibringen können :stupid:

[Bummi]

@Sir Rufo

:thumb: