Object Pascal Compiler

[Tommi]

Hallo! Menschenskinder, die Smilies sind witzig, aber auch ein bissl albern :lol:
Nein, das wollt ich eigentlich nicht loswerden... also ich hab eine etwas spezifische und vielleicht auch exotische Frage und hoffe auf Anregungen von Euch - am besten von denjenigen, die sprachbewandert sind - firm in Object Pascal und vielleicht auch C++.

Zur Zeit opfere ich meine kostbare Freizeit (also wenn ich nicht studiere :) ) unter anderem der Programmierung eines Object Pascal Compilers und eben darum soll es hier auch gehen.

Ich habe Tonnen an Infomaterial aus dem Netz heruntergeladen und studiert, habe mir viel über Compilerbau angelesen und auch aufgrund meiner zaghaften Schritte in Sachen Assembler- und Compilerprogrammierung, die ich seit knapp sieben Jahren gegangen bin, auch schon ein gewisses Verständnis für die Technik und die Grundlagen mir angeeignet. Ich bin allerdings weder Informatiker noch Mathematiker, eher so der sprachbegabte Philologe (hust...), weshalb ich mir auch das hochheilige Recht einräume, bei diesem ambitionierten Vorhaben haushoch zu scheitern :dancer2:

Nun ja, für den Interessierten ein paar technische Details, wie bei mir der Stand der Dinge ist:

Es stehen zur Zeit:

1. Tokenizing (bzw. Scanning)
2. Parsing:
noch nicht fertig - Identifier Table schon angelegt, grobe Regelstrukturen vorhanden
3. Fehlerausgabe

Wirkt alles noch nicht so viel, aber da steckt schon ne ganze Menge Knoffhoff drin (man stelle sich jetzt einen Tusch der Band vor).

Mein derzeitiges Problem dreht sich um die system.pas.
Ich will nämlich prinzipiell alle Grundfunktionen innerhalb der Object Pascal Sprache darin implementieren, ohne irgendwie notbehelfsmäßig im Stile von Turbo Pascal herummauscheln zu müssen.

In gewissen Fällen erfordert dies allerdings eine Syntaxerweiterung, da sowohl Standard, Extended als auch Object Pascal für diese keine "sprachliche" Lösungen vorsehen.

Wie würdet ihr zum Beispiel den Typ String (ShortString) deklarieren?
Was das angeht, stünde ich auf dem Schlauch, aber vielleicht ist ja in Delphi schon was implementiert, wovon ich nichts weiß. Ich besitze nämlich kein Delphi (bin blank und pleite... so ist das Studentenleben), sondern benutze Virtual Pascal. Also für Hinweise wär ich dankbar.

Welche Erweiterungen / Verbesserungen kämen Euch noch in den Sinn - ohne dabei die Schönheit der Pascal-Sprache aufzubrechen? Ich wär für Vorschläge offen.

Ich liebäugele zum Beispiel, ein paar Kleinigkeiten aus C zu leihen. Zum Beispiel -= += oder auch ++ --

So, ich wär dann gespannt auf Eure Antworten und verzeiht mir, daß ich hier soviel geschrieben hab...

[jbg]

Zitat:

Mein derzeitiges Problem dreht sich um die system.pas.

Aha, die Compiler-Magic macht dir sorgen. Wie löst man das Problem von Write/WriteLn(...), usw. Das geht eben nur per Compiler-Magic.

Zitat:

Wie würdet ihr zum Beispiel den Typ String (ShortString) deklarieren?

Mal in Records gesprochen:

Delphi-Quellcode:

ShortString = record
  Len: Byte;
  Chars: array[1..Len] of Char;
end;

Diesen Record kann man so aber nicht in Pascal deklarieren.

Zitat:

Welche Erweiterungen / Verbesserungen kämen Euch noch in den Sinn - ohne dabei die Schönheit der Pascal-Sprache aufzubrechen? Ich wär für Vorschläge offen.

Wie wäre es mit Makros. Bis jetzt muss ich mir da mit meinem eigenen Preprozessor behelfen.

Delphi-Quellcode:

{$define ADD(x, y) ((x) + (y)) }
{$ifdef ADD}
 {$undef ADD}
{$endif}
{$define TO(ClassName, EqualValue, NullValue, RetType)
  function TestObjs(Obj1, Obj2: ClassName): RetType; overload;
  begin
    if Obj.Equal(Obj2) then 
      Result := EqualValue
    else
      Result := NullValue;
  end
}
if TO(TMyClass, 10, 0, Integer) = 10 then ;
if TO(TMyClass2, 2.5, 0, Double) = 0 them ;

Zitat:

Ich liebäugele zum Beispiel, ein paar Kleinigkeiten aus C zu leihen. Zum Beispiel -= += oder auch ++ --

Keine schlechte Idee.

Zitat:

So, ich wär dann gespannt auf Eure Antworten und verzeiht mir, daß ich hier soviel geschrieben hab...

Andere schreiben manchmal viel mehr. :D

[Tommi]

:bounce2: Klasse! Danke für Deine Antwort!

Ich dachte auch schon an Makros und ebenso an einer Anleihe aus C, mit der man Subroutinen (Procedures/Function) mit simplem, kleinem Code, für Geschwindgkeitsoptimierung einfach direkt in den Hauptcode einfließen lassen kann, also ohne Sprungbefehl... was schreib ich da so müdigkeitsduselig... ich hoff, ich drück mich undeutlich genug aus - wie nennt sich das in C??

Und ja, write und writeln wären Sorgenkinder, aber eine Lösung scheint eine Typenart zu sein, mit der man die Parameter für diesen Befehl umschreiben kann. Das ist schon ein bissl unsauber, aber naja. Klar, bleibt mir dann das Tricksen wohl nicht erspart :?

[jbg]

Zitat:

Zitat von Tommi

wie nennt sich das in C??

inline. Und diese Funktionen gab es bereits in TurboPascal, nur waren sie leider auf Byte-Codes (nicht mal Assembler) beschränkt, weshalb Borland sie wahrscheinlich bei Delphi rausgeschmissen hat.

Hast du dir den Quellcode der System.pp von FreePascal mal angeschaut?

[Tommi]

Inline... danke schön!
Ich neig zu Vergeßlichkeit, wenn ich eigentlich längst im Bett liegen müßte :mrgreen:

In einige Teile des Free Pascal Compilers hab ich schon reingeschaut, ebenso in die system.pp ... ich hab in so einige Compiler und Interpreter reingeguckt und was die Leute manchmal für Ideen haben, ist verrückt... das schlimmste Beispiel war ganz übler Spaghetticode, ohne groß von Subroutinen Gebrauch zu machen, sondern irgendwie alles in einen großen Abschnitt mit etlichen Ifs und Cases reingepackt.. hehe, hat mich an meine ersten Schritte in Sachen Compiler erinnert :freak:

Aus der system.pp hab ich sehr wertvolle Informationen ziehen können. Ich bin nämlich zuvor gar nicht auf die Idee gekommen, die Grundtypen (Integers) durch Ranges zu deklarieren... ist eine feine Sache.
Was ich noch nicht ganz verstanden habe, dürfte wohl dieses Compiler-Magic von Free Pascal sein - Umgang und Implementierung von und mit Strings, AnsiStrings und WideStrings. Das scheint über verschiedene units und includes verteilt zu sein... ich werde nochmal genauer reinschauen...

Ach übrigens, ich habe auch irgendwie vor, naturwissenschaftlich-mathematische Erweiterungen hineinzunehmen und habe irgendwo im Netz Pascal-XSC aufgegabelt. Zu dumm, daß ich kein Naturwissenschaftler bin, aber einiges fand ich inspirierend. So zum Beispiel etwas ganz Verrücktes, Functions für ":=" schreiben zu können. Also eine Zuweisung irgendwie umbosseln zu können. Mir entzieht sich der Sinn, aber irgendwas haben sich doch diese klugen Köpfe dabei gedacht.
So und des weiteren die Möglichkeit, mathematische Formeln zu verbalisieren, ich glaube über Typendeklarationen. Ich müßte nochmal genau reinschauen...

[jbg]

Zitat:

Zitat von Tommi

die Grundtypen (Integers) durch Ranges zu deklarieren... ist eine feine Sache.

Und schon weichst du vom dcc32 (Delphi) Compiler ab. Bei diesem sind die Grundtypen im Compiler verankert und nicht in der System.pas


Wie wäre es mit Operator-Überladen?

Delphi-Quellcode:

procedure Operator:=(V1, V2: TMyClass);
begin
  V1.Assign(V2);
end;


var 
  V1, V2: TMyClass;
begin
  V1 := TMyClass.Create;
  V2 := TMyClass.Create;
  try
    V1 := V2; // wird zu Operator:=(V1, V2)
  finally
    V1.Free;
    V2.Free;
  end;
end;

[Tommi]

Naja, ich hatte auch nicht unbedingt vor, einen Delphi-Clone zu basteln...

Könntest Du mir das Assign erläutern, das offenbar zu TMyClass gehört?
Wie schon gesagt, ich hatte mit Delphi bislang noch nicht so viel am Hut - das letzte mal an der Schule und das ist schon ein paar Jährchen her...
Und kannst Du mir vielleicht auch erklären, welchen Sinn der Einsatz von Operator-Überladen macht?

Danke nochmal!


P.S.: Ich hau mich jetzt mal aufs Ohr... :shock:

[jbg]

Das Assign ist eine Methode:

Delphi-Quellcode:

procedure TMyClass.Assign(Source: TPersistent);
begin
  if Source is TMyClass then
  begin
    FField1 := TMyClass(Source).FField1;
    FField2 := TMyClass(Source).FField2;
   // ...
  end;
  else
    inherited Assign(Source);
end;

Das Überladen von Operator kann man sehr gut nutzen um die Rechenoperatoren für eigene Klassen zu deklarieren.
Wenn man z.B. eine Klasse TRealyBigNumer hat, dann ist es doch schöner
BN1 := BN1 + 10 zu schreiben als BN1.Add(10)

[Tommi]

Vielen Dank für Deine Hinweise - ich muß noch gestehen, daß ich erst mit Beginn der Arbeit an diesem Compiler mich in Objekte eingelesen hab, Klassen muß ich noch erlernen, hab mir dementsprechend auch schon Infomaterial herausgesucht...
Mein Pascal-Horizont beschränkte sich vor diesem Projekt wirklich nur auf Extended Pascal und das wars dann auch. Immerhin hab ich ne ganze Menge sodurch lernen können.

Also ich nehm mal an, daß diese Assign Operation innerhalb der Klasse deklariert und auch nur auf Klassen angewandt wird, oder irr ich mich da?

[Duffy]

Hallo Tommi,
ich weiß nicht, ob Du dir mal den GNU Pascal Compiler (BP7 Kompatibel) angschaut hast. Hier könntest Du ein Menge an Knoffhoff ernten.
bye

[Tommi]

Hi Duffy :)

Ja in den GNU Pascal Compiler hab ich auch schon reingeschaut und genau da befindet sich auch - meines Erachtens - eine "Syntaxerweiterung" für die Typendeklaration von ShortStrings...

Nun ja, ich werd mich noch durch einige Dokumentationen durchwühlen müssen... :?

[Tommi]

Mmmkay... irgendwo im Internetz hab ich eine PDF der Delphi 4 doku gefunden und darin auch eine Eklärung für mein Mißverstädnis bezüglich Klassen und Objekte entdeckt - muß mich noch weiter durchlesen. Also Objects werden nur aufgrund Abwärtskompatibilität bewahrt mhm fein... Und Klassen haben bereits vorgefertigte Konstruktoren und Destruktoren...
Aber irgendwie hab ich das Gefühl, daß da Probleme mit meinen Linked-Lists aufkommen, für die ich schon ganz gerne sowohl Konstruktor als auch Destruktor schreiben möchte (bzw. muß), sonst geht meine Identifier Table und mein Token Stream nimmer...
Also kann ich bei Klassen auch selbst Konstruktoren und Destruktoren schreiben?

Und kann mir jemand erklären, wie TObject definiert ist? (oder wo zu finden, ein Link wär ganz hilfreich)

Danke im Voraus!
:D

[jbg]

Zitat:

Zitat von Tommi

Also kann ich bei Klassen auch selbst Konstruktoren und Destruktoren schreiben?

Natürlich kann man eigene Konstruktoren und Destruktoren schreiben.

Delphi-Quellcode:

TMyClass = class(TObject)
  constructor Create(const Irgendwas: string);
  destructor Destroy; override;
end;

Zitat:

Und kann mir jemand erklären, wie TObject definiert ist?

Die FreeCLX enthält unter anderem die System-Units von Delphi/Kylix.

[Garby]

Hallo,

das ist ja eine interessante Diskussion hier :mrgreen: .
Ein paar Kleinigkeiten möchte ich auch beisteuern, die mir in Delphi ein bißchen fehlen:

1.) Den Mengenopereator in[] könnte man vielleicht "aufbohren", damit er auch mit LongInteger Typen klarkommt
2.) die Case-Anweisung sollte auch mit Strings u.dgl. funktionieren
3.) Klassen sollten mehrere Vorfahren haben können

[Tommi]

An jbg: Vielen Dank! Und ebenso danke für Deine Geduld - ich bin kein regelmäßiger Programmierer, es gab bislang Phasen, da hab ich bis zu zwei Jahre nicht einen Compiler angefaßt, aber mich mit anderen Dingen beschäftigt, also fehlt mir da schon die Kontinuität und in Sachen Objekte und Klassen bin ich erst vor wenigen Wochen durchgestiegen, obwohl ich sie seit gut drei Jahren in Form von JavaScript schon angewandt hab :oops:

An Garby: großartige Idee mit den Cases..., das mit Klassen muß ich echt noch irgendwie detailierter nachlesen... ohje... demnach kann ich jetzt auch nicht verstehen, daß sie nicht mehrere Vorfahren haben können.
Auf wieviele sind sie denn beschränkt?

So, nachdem ich das mit den Constuctors und Destructors erfahren hab, kann ich ja getrost die "Object"s in "Class"es umschreiben :)

[jbg]

Zitat:

Zitat von Tommi

Auf wieviele sind sie denn beschränkt?

Auf einen Vorfahr.
Mir ist aber bis jetzt noch kein Klassenbaum untergekommen, in dem eine Klasse mehrere Vorfahren haben musste. Und sollte das dann doch irgendwann einmal eintreten, gibt es immer noch den Umweg über Interfaces.

[Garby]

Ich hätte einen Anwendungsfall:

Bsp:
ich leite mehrere StandardVCL Komponenten ab, z.B. von TEdit, TDBEdit, TComboBox, TPanel.
Diese Komponenten erhalten dieselben neuen Properties(z.B. die laufende Nummer eines Datensatzes einer Tabelle, in der Mehrsprachigkeit oder evtl. ein Hilfesystem abgebildet ist).

Da würd sich doch folgendes anbieten:

Delphi-Quellcode:

type
  TMyControl = class(TWinControl)
  private
    FmyHelpID: Integer;
  public
    procedure ShowHelp;
  published
    property myHelpID: Integer read FmyHelpID write FmyHelpID;
  end;

  TMyEdit = class(TEdit, TMyControl)
  end;

-----------------------------

procedure TMyControl.ShowHelp;
begin
  ShowMessage(GetHelpTextFromDB(myHelpID));
end;

procedure TForm1.FormKeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  if (Key = VK_F3) and (Shift = []) and (ActiveControl is TMyControl) then
    TMyControl(ActiveControl).ShowHelp;
end;

Oder hast du da eine andere Lösung parat?

[jbg]

Delphi-Quellcode:

type
  THelpEx = class
  private
    FOwner: TComponent;
    FmyHelpID: Integer;
  public
    constructor Create(AOwner: TComponent);
    procedure ShowHelp;
  published
    property myHelpID: Integer read FmyHelpID write FmyHelpID;
  end;

TMyEdit = class(TEdit)
private
FHelpEx: THelpEx;
procedure SetHelpEx(Value: THelpEx);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
published
property HelpEx: THelpEx read FHelpEx write SetHelpEx;
end;

constructor TMyEdit.Create(AOwner: TComponent);
begin
inherited;
FHelpEx := THelpEx.Create(Self);
end;

destructor TMyEdit.Destroy;
begin
FHelpEx.Free;
inherited;
end;[/delphi]