eigene Sprache: soll ich das bauen?

Es gibt 25 Antworten in diesem Thema. Der letzte Beitrag () ist von filmee24.

    eigene Sprache: soll ich das bauen?

    hallo,
    ich hatte vorhin eine Idee eine Klassenbeschreibungssprache zu definieren. Das habe ich auch gemacht.

    Name: Class Description Language (.cdl)

    Beispielcode

    Class: (Public) Messagemanager

    Property: (Public) Messages == List(from MessageItem)

    Function: (Public) AddMessage <id,message,[categorie=Default]> :: void
    Function: (Public) RemoveMessage <id> :: void
    Function: (Public) RemoveCategorie <categoriename> :: void

    Function: (Public) getCategories <> :: Array
    Function: (Public) getCategorieIds <categoriename> :: Array
    Function: (Public) LoadMessage <id, [categoriename=Default]> :: String

    Function: (Public) EditMessage <id,newmessage> :: void
    Function: (Public) CountCategories <> :: Integer
    Function: (Public) CountMessages <> :: Integer

    Function: (Public) ClearMessages <> :: void
    Function: (Public) ClearIds <> :: void
    Function: (Public) Clear <> :: void

    Function: (Public) EditMessageFromMessage <message,newmessage> :: void
    Function: (Public) Insert <index,item> :: void

    List: (Public) Sortstate == Enum

    Function: (Public) Sort <status> :: void
    Function: (Private) SortId <> :: void
    Function: (Private) SortMessage <> :: void

    Class: (Public) MessageItem

    Property: (Public) ID == String
    Property: (Public) Message == String
    Property: (Public) Categorie == String

    Constructor: <id,message, categorie>
    Constructor: <>

    Function: (Public) --ToString <> :: String

    Class: (Public) MessageItemIdComparer : IComparer(from Messageitem)

    Function: (Public) Compare <x,y> :: Integer

    Class: (Public) MessageItemComparer : IComparer(from Messageitem)

    Function: (Public) Compare <x,y> :: Integer



    Diese Syntax finde ich sehr in Ordung.

    Was haltet ihr von der Syntax?

    Ich möchte einen kleinen Parser bauen, und einen Code-Generator: der mir den Code generiert den ich definiert habe, und einen HTML-Generator um die Klassen in Farbe direkt zum Anschauen zu haben.

    Was haltet ihr davon?

    Vielen Dank

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „filmee24“ ()

    Kannst Du eine Zielgruppe definieren, die das brauchen könnte?
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    z.b. du sollst für einen Freund der genaue Vorstellungen hat welche Funktionen und co. die Klasse haben soll,programmieren aber er kann nicht programmieren, und du möchtest es schnell aufschreiben damit alles Perfekt wird, so wie dein Freund es will.

    oder du hast eine Idee wo anders, und hast gerade aber keinen Computer parat, so kannst du diese Sprache nutzen, um alles zuz definieren wie deine Klasse aussehen soll.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „filmee24“ ()

    filmee24 schrieb:

    oder du hast eine Idee wo anders, und hast gerade aber keinen Computer parat, so kannst du diese Sprache nutzen, um alles zuz definieren wie deine Klasse aussehen soll.

    Das mach ich doch dann am PC wenn ich mir das Klassendesign überlege, und nicht wenn mir ein Freund sagt, das er gerne ein 0815 Programm hätte.
    Außerdem, wo soll das Praktisch sein? Ich sehe keinerlei Vorteile. Man kann Klassen und Funktionen so Kommentieren, das sie wenn man die Funktion benutzt per ToolTip Informationen eingeblendet werden ;)

    ah okay oO
    Da kann ich mir aber auch nen Block undn Stift nehmen und das Manuell machen.
    Also:

    Quellcode

    1. Klassen Name
    2. | - Member:
    3. | - - int Auflistung whatever
    4. | - Events:
    5. | - - Event mit whatever etc unso und crap
    6. | - Privat:
    7. | - - whatever methoden und funtkion und params etc. mit Verweis auf einen Teil irwo anders aufm Blatt
    8. | - Public:
    9. | - - whatever crap etc mit verweis auf einen teil irwo anders aufm Blatt

    Du kannst dich mal an YAML orientieren wenne das wirklich machen willst.

    Quellcode

    1. root-Node:
    2. property-name:
    3. whateveruntertzweig:
    4. wert: wert
    5. was-anderes: wert

    stackoverflow.com/questions/42071/net-yaml-library
    yaml.codeplex.com/
    So kannste auch deinen eigenen Parser bauen...aber eben basieren auf YAML.
    Wäre, imho, die einfachste Variante wie man das machen kann.

    Ich finde die Idee gut. Ist wenigstens ein sinnvolles Projekt im Gegensatz zu so manch anderem Kram hier ;-)

    Es wäre allerdings noch viel sinnvoller, wenn du eine generelle Syntax definierst die Sprachunabhängigkeit hat. Dann könnte man mit "einem Klick" nach VB.NET, C#, C++, ... exportieren. Man kann noch weiter spinnen und automatisch Methodenstubs erstellen und Proprtyfelder automatisch erstellen... Da gibt es viel Potential zum ausbauen. Und kann demnach auch entsprechend komplex werden.

    Wenn du es richtig machst, wird es ein spannendes Projekt.

    @icemanns: vor UML braucht man hier keine Angst haben. In UML muss man zeichnen. Dagegen bin ich als Informatiker allergisch :>
    To make foobar2000 a real random music player, I figured out the only way to achieve this is to use Windows Media Player.

    “At some point in time, you recognize that knowing more does not necessarily make you more happy.”

    dann aber bitte nicht mit sowas komischem.
    Funktionen mit "::" und Propertys mit "=="..wo is da die Logik?
    Wenn dann alles wirklich einheitlich.

    Quellcode

    1. Klassenname:
    2. funktionsname:
    3. type: function
    4. accessor: public
    5. returntype: int
    6. params:
    7. param1: int
    8. param2: string
    9. param3: somethingelse
    10. throws:
    11. - IOException
    12. - InvalidArgumentException
    13. methodname:
    14. type: method
    15. accessor: private
    16. params:
    17. param1: thing
    18. throws:
    19. - IOException
    20. - ParameterNotNullException
    21. readonlypropertyname:
    22. type: property
    23. returntype: thing
    24. localvar: _readonlypropertyname
    25. get:
    26. accessor: public
    27. propertyname:
    28. type: property
    29. returntype: int
    30. localvar: _propertyname
    31. get:
    32. accessor: public
    33. set:
    34. accessor: private

    Ich bin ja immernoch dafür, dass man YAML dafür nutzt. Das ist dafür fast wie geschaffen.
    Außerdem ists dadurch sehr einfach z.B. in andere Sprachen zu expotieren.
    Wenn @filmee24: das wirklich so machen KANN, dann wärs wirklich epic.

    Das Problem an deiner Syntax ist (also an @AliveDevil:s), dass man ultra viel schreiben muss. Wenn man bei einer typischen, echten Definition bleiben würde - wie er Threadautor es gemacht hat - geht es viel schneller zu schreiben.

    Man sollte auch darauf achten, dass Sonderzeichen für Handschreiber schwieriger zu schreiben sind: (, <, >, ), {, }, und so weiter...
    To make foobar2000 a real random music player, I figured out the only way to achieve this is to use Windows Media Player.

    “At some point in time, you recognize that knowing more does not necessarily make you more happy.”

    ok, ich werde das wohl in yaml machen, mit exportfunktion in manche .net Sprachen, leere Property und leere Substubs.
    Vielen Dank für die Tipps


    Hier die neue Syntax:

    Quellcode

    1. Klassenname:
    2. funktionsname:
    3. type: function
    4. accessor: public
    5. returntype: int
    6. params:
    7. param1: int
    8. param2: string
    9. param3: somethingelse
    10. throws:
    11. - IOException
    12. - InvalidArgumentException
    13. methodname:
    14. type: method
    15. accessor: private
    16. params:
    17. param1: thing
    18. throws:
    19. - IOException
    20. - ParameterNotNullException
    21. readonlypropertyname:
    22. type: property
    23. returntype: thing
    24. localvar: _readonlypropertyname
    25. get:
    26. accessor: public
    27. propertyname:
    28. type: property
    29. returntype: int
    30. localvar: _propertyname
    31. get:
    32. accessor: public
    33. set:
    34. accessor: private



    soll ich aber noch einbauen das man implements und inherits nutzen kann?

    * wo finde ich eine free Lib, um Yaml zu parsen?

    Ah genau...das Implements und Inherits Zeug.
    YAML

    Quellcode

    1. Klassenname:
    2. inherits:
    3. - Namespace.Klasse
    4. - Namespace.Interface
    5. implements:
    6. - Somethingelse
    7. funktionsname:
    8. type: function
    9. accessor: public
    10. returntype: int
    11. params:
    12. param1: int
    13. param2: string
    14. param3: somethingelse
    15. throws:
    16. - IOException
    17. - InvalidArgumentException
    18. methodname:
    19. type: method
    20. accessor: private
    21. override: true
    22. params:
    23. param1: thing
    24. throws:
    25. - IOException
    26. - ParameterNotNullException
    27. overloads:
    28. overload1:
    29. params:
    30. param1: int
    31. param2: thing
    32. throws:
    33. - ~
    34. overload2:
    35. params:
    36. param1: int
    37. throws:
    38. - ~
    39. readonlypropertyname:
    40. type: property
    41. returntype: thing
    42. localvar: _readonlypropertyname
    43. get:
    44. accessor: public
    45. propertyname:
    46. type: property
    47. returntype: int
    48. localvar: _propertyname
    49. get:
    50. accessor: public
    51. set:
    52. accessor: private

    Da brauchste für die Implement- und Inherit-Sachen aber die Definitionen von M$, damits später auch korrekt exportiert wird. Override gibts natürlich auch.
    So..für die Overloadsachen hab ich gleich was dazu gebastelt. Sollte eig. relativ logisch sein.
    Sonst, @Chrisber: muss man für die Überladungen das ganze nochmal schreiben etc. hier also etwas geschrumpfter.
    Sollte sich also ausgleichen.

    Aber(!) du musst darauf achten, dass die YAML Parameter etc. immer richtig eingerückt sind. Sonst gibts Probleme später beim parsen. Z.B. dürfen keine Tabulatoren etc. genutzt werden.

    Das mit dem "throws"-Zeug, kann man leider nur in Java nutzen, da das .NET Framework sowas nicht (hoffentlich bald) unterstützt.

    Für Lib: schau in Post #7

    Die Lib dazu wurde oben gepostet ( die auf codeplex gehostet ist ). Also ich finde den Einwand von Chrisber wichtig und denke, dass die vorgestellte Syntax schon recht passabel ist ( fehlt mir noch die Möglichkeit der Namespaces, aber das ließe sich doch sicher kombinieren -> YAML-Syntax für Namespaces, Rest über deinen Anfang)

    Aber was schreibst du schneller?
    "<int>"
    oder
    "param: int"

    Ich will den TE ja nicht auf YAML festlegen, sondern eher Verbesserungsvorschläge geben.
    Z.B. das mit Variable wird mit "==" festgelegt, ne Funktion mit "::". Erkläre mir da einer den Sinn.
    auch son paar andere Sachen, wie "Name <int, int, shit>" kann man doch, zwecks besseren schreibens auf "Name (int, int, shit)" verändern.
    die Default-Sachen kann man ähnlich machen "Name <int, [int=Drölf]>" oder "Name (int, int=Drölf)".
    Das wären auch so meine Sachen, die man an der genannten Syntax ändern könnte.
    Evtl. bringe ich nochmal nen veränderten Vorschlag für die original Syntax von @filmee24: ein.
    Ist aufjedenfall n nettes Projekt, vorallem wenn man so seinen Code einfach verteilen kann.