PSharp2 - Die neue Programmiersprache

Hi.

Ich habe wiedermal ein neues Projekt in Angriff genommen 😁

Diesmal ist es die Programmiersprache "PSharp2" (Es gab auch mal eine Version 1, die hat es aber nie an die öffentlichkeit geschafft).

Hier ist mal ein kleines Codebeispiel, an dem man erkennen kann, wie der Syntax ungefähr aussieht:

 [color]Namespace [/COLOR]Hallo
{
         [COLOR]Class[/COLOR][COLOR] Main [/COLOR][COLOR]Public Static[/COLOR]
         {
                [COLOR] Method [/COLOR][COLOR]Main[/COLOR][COLOR] Public Static[/COLOR]
                 {
                         [COLOR]var[/COLOR][COLOR]:[/COLOR][COLOR]string[/COLOR] i = [COLOR]"Hallo, Welt!"[/COLOR];
                         System.Console[COLOR]::[/COLOR]WriteLine(i);
                         System.Console[COLOR]::[/COLOR]ReadKey();
                }
         }
}

Mit diesem Thread möchte ich ein paar Leute werben, die mir als Tester helfen können. Da die ganze Sache aber noch ultra Buggy ist 🙁 , möchte ich meinen Compiler hier noch nicht veröffentlichen.

Bei Interesse kann man sich bei mir über Skype melden (Anzeigename pdelvo).

Ich habe auch mal einen Screenshoot angehangen.

Gruß pdelvo

Ich find die Syntax ein wenig, hmm... seltsam.

Bei den Klassen und Methoden hast du ja ein Muster in der Art:

Typ Name Modifier

Wie würde bei Methoden jetzt der Rückgabetyp angegeben werden? Bei der Main wird ja nichts angegeben als Rückgabetyp. Wie gibst du bei Klassen Interfaces und Basisklassen bei Vererbung an?

Bei der Variablen hast du dann nen Muster in der Art

Typ:Datentyp Variablenname = Wert;

Wo würden dort eventuelle Modifier hinkommen? Warum der Doppelpunkt dort?

Des sind nur so nen paar Fragen die mir in den Sinn kommen wenn ich die Syntax sehe. Die ist natürlich Sache des Entwicklers, aber ich persönlich zumindest, finde die nicht optimal, weil sie irgendwie inkonsequent ist.

Ich find die Syntax ein wenig, hmm... seltsam.

Ich wollte nicht unbedingt alles aus c# kopieren. Das fände ich einfach zu langweilig.

Wie würde bei Methoden jetzt der Rückgabetyp angegeben werden?

Da habe ich auch schon eine lösung, die auch funktioniert, die ich aber selber nht ganz schön finde. Die wird noch geändert. Am besten ich schreibe hier mal eine größere Methode. Da sieht man mehr.

          Method MacheIrgendwas Public Static Ret:System.ConsoleKeyInfo Params string a
          {
               System.Console::WriteLine(a);
               ret System.Console::ReadKey();
          }

Wie gesagt. Das Ret:[Typ] gefällt mir selber noch nicht.

Wie gibst du bei Klassen Interfaces und Basisklassen bei Vererbung an?

Da wollte ich wie in C# den Doppelpunkt verwenden. Das steht aber erstmal ganz hinten auf meiner Liste.

Wo würden dort eventuelle Modifier hinkommen?

Das var: gilt nur innerhalb einer Methode. Außerhalb werden Variablen nach dem Schema von Klasse deklariert. Das gibt es aber auch noch nicht.

Warum der Doppelpunkt dort?

Um var vom Typ zu trennen =)

Ob das alles so kommt wie ich Sage, steht aber noch nicht fest. Ich kann das ja ändern wie ich lustig bin 😁

Danke für deine Antwort.

Gruß pdelvo

Hallo pdelvo,

wenn ich dich richtig verstehe, programmierst du also C# mit einer anderen Syntax nach. So zur Übung. Denn eigentlich würde man ja bei einer neuen Sprache nicht nur eine neue Syntax sondern vor allem eine neues Konzept oder neue Möglichkeiten einführen. Davon kann ich nichts erkennen.

herbivore

Ja. In erster inie mache ich das zum Üben.

Gruß pdelvo

Hallo pdelvo,

Denn eigentlich würde man ja bei einer neuen Sprache nicht nur eine neue Syntax sondern vor allem eine neues Konzept oder neue Möglichkeiten einführen.

Na dann mal los: *Null Dereferencing Operator
Vorschlag: http://haacked.com/archive/2009/07/14/law-of-demeter-dot-counting.aspx

// a wird null, wenn foo, bar oder baz null sind (anstatt eine NullReferenceExeption zu werfen)
object a = foo.?bar.?baz.?qux;

*Non-Null Types

// foo ist niemals null (obwohl Referenztyp)
void test(Foo! foo) { }

Kann schon: http://research.microsoft.com/en-us/projects/specsharp/

😁
dN!3L

sind die erstellten programme ohne irgendein framework lauffähig?

Hallo zerberos

Natürlich nicht, wenn die Sprache mit C# entwickelt wird 😃.

Gruss Peter

Ich erzeuge IL code, wie der C# Compiler auch. Sie sind also nicht ohne .net Framework lauffähig.

Gruß pdelvo

Ich habe an der SPrache weiterentwickelt und.

Ich habe es jetzt so gemacht, dass der Returnwert direkt hinter die Methode gehört. Außerdem funktionieren nurn einfach If abfragen. Außerdem gab es kleinere Bugfixes.

Hier mal mein Zwichenstand

Namespace Hallo 
{
	Class Program Public Static
	{
          Method void Do Public Static Params string a
          {
               System.Console::WriteLine(a);
          }
		Method int Main Public Static
		{
			var:int i = 5;
			i = i + 6;
                this::Do ("Hallo, Welt!");
                var:string u = System.Console::ReadLine();
                if( u == "Hallo")
                {
                    System.Console::WriteLine("Hallo");
                }
                else
                {
                    System.Console::WriteLine("Hi");
                }
			ret 0;
		}	
	}
}

Wenn jemand Lust hat sich das anzusehen kann er sich bei mir melden.

Gruß pdelvo

Ich hab wieder mal ne Anmerkung zur Syntax 🙂

this::Do ("Hallo, Welt!");

sieht definitiv komisch aus.
Du hast ja deinen Modifiern zufolge ne statische Klasse mit statischen Methoden. In allen mir bekannten objektorientierten Sprachen ist this nen Zeiger auf die aktuelle Instanz. Deshalb frag ich mich, auf was this sich bei dir bezieht wenns gar keine Instanzen irgendeiner Klasse gibt. Auch wenn das this:: bei dir einen Zweck erfüllt, würd ichs nicht this nennen, da das doch ne andere Bedeutung i.d.R. hat.

Den Logmeldungen des ersten Screenshots nach, richtest du dich ja an das klassische Vorgehen mit Scannen, Parsen, usw.. Schreibst du dabei Scanner und Parser selber, oder lässt du dir die generieren aus der Sprachdefinition mit Tools ähnlich zu Lex und YACC?

Ich brauche this um zu erkennen, dass die Methode in der selben Klasse liegt. Sonst hätte ich das weggelassen,oder optional gemacht. Ich schreibe Scanner und Parser komplett selber.

Gruß pdelvo

Ich veröffentliche hier mal eine ALPHA Version um ein wenig mehr Feedback zu bekommen.Ich weiß dass sie noch voller Bugs ist.

Die Lizenz der Docking Komponente liegt bei.

Gruß pdelvo

Mal aus Neugier: Wie funktioniert das ganze technisch gesehen?

Hi,

Mein Compiler ist in 3 Schritte aufgeteilt, die nacheinander abgearbeitet werden. Scanner, Parser CodeGenerator (Später kann noch ein Optimierer dazukommen).

Dier Scanner geht Zeichen für Zeichnen dur ch den Quelltext und erkennt Strings, ints, Sonderzeichen und packt diese in eine Liste. Dabei sind bei mir Schlüsselwörter, Klassennamen, Methodennamen, etc. StringBuilder, Strings sind strings, int sind ints und Sonderzeichen werden in Instanzen eines Enums gespeichert.

Danach kommt der Parser. Dieser versuchet den Quelltext zu verstehen, indem er ihn in einen Abstract Syntax Tree packt. Dazu habe ich eine Menge Klassen erstellt, wie zB SetVarExpression. sie hat einen string Identifier und wiederum eine Expression, die den Zugewiesenen Wert oder Ausdruck darstellt. Dies kann ein int, ein string, eine Mathematische Operation, ein Methodenaufruf... sein.

Zum Schlüss kommt der CodeGenerator. Dieser übersetzt nurnoch meinen AST in IL. Habe ich zB eine SetVar Expression, so übersetze ich erste den rechten Teil vom Gleichzeichen und danach muss ich nurnoch StLoc aufrufen, damit der Wert gespeichert wird.

Der Optimierer würde dann zwichen Parser und CodeGEnerator kommen. Da könnte man nicht gebrauchte Variablen entfernen etc.

Hier ist noch ein guter Link: MSDN Webcasts: Ein neuer Compiler in einer Stunde - Programmiersprachen bis zum Abwinken

Gruß pdelvo

Hi,

Mir ist gerade so eine Idee gekommen. Und zwar gibt es in C++ ja ein __asm schlüsselwort um direkt ch fände es richtig cool wenn ich ein IL Schlüsselwort einbaue, mit dem man direkt IL reinschreiben kann. Ein Anwendungsbeispiel wäre zB eine Swap methode, die den wert zweier Variablen tauschen kann, ohne eine Diritte Variable. Das kann man machen indem man die Variablen auf dem Stack ablegt. Was haltet ihr von dieser Idee? Wenn sie gut ankommt werde ich sie eventuell einbauen wenn mein PC wieder heile ist. Vorausgesetzt es ist machbar.

Gruß pdelvo

Hehe, in meinem Augen sieht es wie ein Gemisch von Pascal(Delphi) und C++/C# aus. Ist bestimmt lustig, mit dieser Sprache zu programmieren.

Fände ich ganz lustig auch wenn man es eher selten benutzen würde. Aber abwegig ist die Idee nicht und andere Leute haben diesen Gedanken ebenfalls schon mal aufgefasst:
Tool to allow inline IL in C# / VB.Net

Das ist ja cool. Das muss ich mir später unbedingt mal ansehen.

Gruß pdelvo

Hallo,

Ich hätte da einmal eine Idee, die vielleicht für so eine .NET Sprache generell interessant wäre.

Mich nervt es immer, dass einige Frameworks die mit Reflection arbeiten natürlich nur aus Strings auf Binding-Pfade schließen können, das ist aber beim Refactoring extrem unpraktisch, habe mir deswegen schon mal gedacht, dass eine Binding-Expression auf Spracheben sinnvoll wäre, z.B. bei einem OR-Mapper:

Filter.Eq(#{MyClass.PropertyName}, id);

Das kann von der Sprache getestet werden und liefert dann entweder ein bekanntes Interface oder direkt ein PropertyInfo/MemberInfo Object.

mfg
Joe

Hallo Joe

Lambda Expressions in Verbindung mit Expression Trees könnte man doch da benutzen.

• http://blog.andreloker.de/post/2008/06/12/Getting-rid-of-strings-(2)-use-lambda-expressions.aspx

Gruss Peter

Hi Peter,

Lambda Expressions in Verbindung mit Expression Trees könnte man doch da benutzen.

Ich muss zugeben, bisher habe ich mich nicht so sehr mit den neuen C# 3.x Features auseinander gesetzt. In erster Linie weils Mono noch nicht vollens kann und ich eher möglichst Plattformunabhängig bleiben möchte.

Du hast recht, das würd schon klappen. Obwohl das ganze für meinen Geschmack etwas zu wuchtig ist. Also wenn mans "gratis" in der Sprache haben kann - einen direkteren Reflectionzugriff - würd mich das nicht stören.

Gruß
Joe

Hi, pdelvo.

Auch ein nettes Feature wären Try-Filter und ein Fault-Block:

Beispiel-Syntax:

[color]Try[/color] {
 [color]// Do Something...[/color]
}
 [color]Catch[/color] ex:SpecificException [color]When[/color] Condition(ex) {
 [color]// Execute handler for SpecificException only if Condition(ex) returns true[/color]
}
 [color]Catch[/color] ex:Exception {
 [color]// Execute handler for all exceptions[/color]
}
 [color]Fault[/color] {
 [color]// Execute only if a exception has been thrown[/color]
}
 [color]Finally[/color] {
 [color]// Well-known finally block[/color]
}

Siehe Link

Gruß, Christian.

Achso. Das ist praktisch.

Gruß pdelvo