Prozedur-Parameter mit variantem Typ?

[dizzy]

Uffa!

Damit mache ich mir aus einem 3-Zeiler einen 20-Zeiler:
Vorher: (für den reellen Modus)

Delphi-Quellcode:

currentND := TRNode.Create(opAdd);
TTR(anfang(s,'+'), currentND.subNodes[0]);
TTR(ende(s,'+'),   currentND.subNodes[1]);

Nachher: (universal mit TObject als "Knotencontainer")

Delphi-Quellcode:

if currentND is TRNode then
begin
  currentND := TObject(TRNode.Create(opAdd));
  TTR(anfang(s,'+'), TObject(TRNode(currentND).subNodes[0]));
  TTR(ende(s,'+'),   TObject(TRNode(currentND).subNodes[1]));
end
else
if currentND is TCNode then
begin
  currentND := TObject(TCNode.Create(addC));
  TTR(anfang(s,'+'), TObject(TCNode(currentND).subNodes[0]));
  TTR(ende(s,'+'),   TObject(TCNode(currentND).subNodes[1]));
end
else
if currentND is TQNode then
begin
  currentND := TObject(TQNode.Create(addQ));
  TTR(anfang(s,'+'), TObject(TQNode(currentND).subNodes[0]));
  TTR(ende(s,'+'),   TObject(TQNode(currentND).subNodes[1]));
end;

Und solche Teile stehen dann satte 28 Mal untereinander... Das hier war ja nur für den Fall, dass ein "+" gefunden wurde. Da kommt noch -,*,/,^ und das ganze Sinus-Cosinuns-Zeug und die 8 (naja eigentlich 24) Variablen, UND der Fall, dass eine reine Zahl als Konstante im String steht...
Bisher habe ich also diese 28*3-Zeiler 3 Mal (für jeden Zahlentyp ein Mal), und mit der obigen Änderung käme ich nicht auf eine Verdreifachung an Zeilen, sondern auf eine Verzwanzigfachung Ganz zu schweigen von dem irren Gecaste, das der Übersichtlichkeit ja noch mehr ans Bein pinkelt
Rein technisch sicherlich eine machbare Lösung - aber mein Ziel, die Übersichtlichkeit und Eleganz zu verbessern - erreiche ich fürchte ich SO nicht :\
Kann man da nicht etwas (sehr) komfortabler dran gehen?


gruss,
dizzy


\\edit:
Oder fragen wir anders: Kann man in Klassendeklarationen evtl. ähnlich vorgehen wie bei varianten Records??
Quasi:

Delphi-Quellcode:

  TNumFormat = (nfReal, nfComplex, nfQuaternion);

  TCQParser = class(TObject)
  private
    rootR: TRNode;
    rootC: TCNode;
    rootQ: TQNode;
    procedure FlushTrees;
    // sowas in der Art?
    case NumberFormat of
      nfReal:       procedure TTR(s: string; var currentND: TRNode); overload;
      nfComplex:    procedure TTR(s: string; var currentND: TCNode); overload;
      nfQuaternion: procedure TTR(s: string; var currentND: TQNode); overload;
    end;
    //------------------
  public
    // grausig hier... :)
    Ar, Br, Cr, Dr, Er, Fr, Gr, Hr: double;
    Ac, Bc, Cc, Dc, Ec, Fc, Gc, Hc: TComplex;
    Aq, Bq, Cq, Dq, Eq, Fq, Gq, Hq: TQuat;
    NumberFormat: TNumFormat;
    procedure Parse(s: string);
    procedure Solve(var res: double); overload;
    procedure Solve(var res: TComplex); overload;
    procedure Solve(var res: TQuat); overload;
    constructor Create;
    destructor Destroy; override;
  end;

Dass es genau so NICHT geht, hab ich schon bemerkt Aber könnte man so etwas ähnliches basteln?