Scripti - Eine kleine Skriptsprache für simple Aufgaben

    • Beta
    • Open Source

    Es gibt 43 Antworten in diesem Thema. Der letzte Beitrag () ist von masterm.

      Scripti - Eine kleine Skriptsprache für simple Aufgaben

      Scripti

      Scripti ist ein Interpreter von Skriptdateien. Der Syntax ist relativ simpel: (Gruppe.)Befehl:(Argument)(;Argument)(...)
      Es gibt verschiedene Gruppen, in welchen Befehle gesammelt sind. Für einige Befehle müssen Argumente angegeben werden. Diese werden durch einen Doppelpunkt ":" vom Befehl getrennt (der Doppelpunkt muss immer vorhanden sein). Die Argumente untereinander werden durch Semikolons ";" getrennt.
      Beispiel ist folgender Befehl: io.movedirectory. Dies ist der Syntax: file.movedirectory:alterordner;neuerorder;überschreiben. Das Argument alterordner gibt den zu verschiebenen Ordner an, neuerorder ist das Zielverzeichnis und überschreiben legt fest, ob der Zielordner überschrieben werden soll, wenn er bereits existiert. Das letzte Argument kann bei diesem Befehl weggelassen werden. Gegebenenfalls fragt der Interpreter nach.

      Unter github.com/master-m1000/Scripti/ findet ihr den Quelltext.

      Ich suche fleißige Tester! Wir sind noch laaaange nicht am Ziel, sondern haben gerade erst 7 Zentimeter von 1000 Kilometer zurückgelegt. Ich bin auf euer Feedback angewiesen und freue mich auf die Zusammenarbeit.

      Infos:
      Größe des Interpreters: ca. 192 KB
      Entwickelt mit Visual Studio 2015 in Visual Basic Community (Framework Version 4.0)

      Aktuelle Version: 0.1.1.0
      Zur Versionsübersicht

      Download: als Setup oder als Zip
      Lizenz (MIT License)

      Screenshots:
      Spoiler anzeigen


      Hier mal ein Beispiel von einem Script:
      Spoiler anzeigen

      Quellcode

      1. |SCRIPTI SCRIPT FILE VERSION 0.1.0.0
      2. ' <- This at the beginning of a line marks a comment
      3. me.write:This is a test!
      4. me.write:
      5. me.write:Now we're going to change the color...
      6. me.color:3;11
      7. me.pause:
      8. me.write:And back!
      9. me.resetcolor:
      10. me.write:Tada!
      11. me.pause:
      Alle Angaben sind ohne Gewähr, jedoch mit Pistole. Glücksspiel, Drogen und leckeres Essen können süchtig machen.

      43232069737420636f6f6c21

      Dieser Beitrag wurde bereits 6 mal editiert, zuletzt von „masterm“ ()

      Wie wäre es, wenn du erstmal die wichtigsten Sachen wie Userinputs, Variablen, ... implementierst? Außerdem wäre praktisch, einen Befehl zu haben, welcher es erlaubt, Cmd-Befehle zu senden. So wie sie jetzt ist, ist diese "Skriptsprache" so gut wie nutzlos.

      Warum hast du bei den Befehlen Deutsch und Englisch gemischt?

      Quellcode

      1. file.deletefile
      2. kommentar
      3. show
      4. startprogramm


      Das irritiert! Die Idee ist aber nicht schlecht und die Syntax recht einfach zu verstehen. Wenn du jetzt noch mehr Befehle und die Funktion, dass eine Skriptdatei auch per Doppelklick ausgeführt werden kann hinzufügst, wäre dein Projekt echt nützlich!

      Edit: Eine Frage habe Ich aber noch: Muss der ganze Skript in einer Zeile geschrieben sein? Hab gerade dein Wiki gefunden, liegt wohl an der Kodierung deiner Beispieldatei.

      @ichduersie Das zweite m in "startprogramm" ist mir auch schon aufgefallen und entfernt. Ein Kommentar wird mit einem Apostroph am Zeilenanfang angegeben. Ich habe ein Setup geschrieben, mit dem es per Doppelklick gestartet wird, aber die Deinstallation buggt noch, weswegen ich diese keinem antun wollte ;)

      @nafets Eine cmd-Implementierung - oder wie man es auch immer nennen möge - ist eine gute Idee. Ich habe aber keine Ahnung, wie ich diese umsetzten könnte. Variablen sind nur beschränkt vorhanden (10 Strings). Ich weiß leider nicht, wie ich dies dynamisch umsetzten soll.

      Wir befinden uns noch in der Alpha. Wir haben erst zwei Zentimeter von tausend Kilometern (ums mal etwas poetischer zu sagen ;) )
      Alle Angaben sind ohne Gewähr, jedoch mit Pistole. Glücksspiel, Drogen und leckeres Essen können süchtig machen.

      43232069737420636f6f6c21

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

      So, die 0.0.3.0 ist da mit ein paar Änderungen. Das Wiki wurde jetzt komplett auf die neuen Befehle aktualisiert und ist nun vollständig. Das zweite "m" bei startprogramm wurde entfernt und ein neuer Befehl hinzugefügt. Mehr Infos im Changelog. Dort findet ihr auch den Download-Link. Falls ein Problem auftritt oder ihr Vorschläge habt, könnt ihr mich gerne hier im Forum kontaktieren.
      Alle Angaben sind ohne Gewähr, jedoch mit Pistole. Glücksspiel, Drogen und leckeres Essen können süchtig machen.

      43232069737420636f6f6c21

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

      Hey @masterm
      Ich habe mir mal die Zeit genommen deinen Interpreter zu testen. Mir sind ein paar Dinge aufgefallen. Zuerst einmal habe ich es installiert und habe sogleich begonnen ein Script zu erstellen, wobei ich erstmal suchen musste was ich für einen Typ nehmen muss(habe ich dann aus deinen Screenshots entnommen).
      Positiv ist schonmal, dass die Scripts gleich auf dein Programm zugreifen wenn man sie doppelklickt. Ich habe dann mal die ersten Zeilen geschrieben und musste feststellen, dass der Interpreter einen Fehler auswarf.
      Ich habe dann bemerkt, dass ich vergessen habe an den Anfang zu setzen "|SCRIPTI SCRIPT FILE VERSION 0.0.3.0". Soweit so gut. Ich habe etwas herum experimentiert und kann nun sagen, dass die Syntax gut zu verstehen ist. Ich habe CopyDirectory ausprobiert, aber es wirft mir da einen Fehler aus, aus dem ich nicht die Ursache schließen kann. Vielleicht hängt es mit den : zusammen oder ich mache da einfach einen groben Fehler.

      Vielleicht könntest du ja ein kleines Tutorial erstellen, wie man solche Dateien richtig schreibt?
      Auch ist mir die Namensnennung etwas Suspekt aufgefallen: Es ist mMn etwas seltsam, dass du mit "File." Dateien und Ordner behandelst. Vielleicht benennst du es ja in sowas um wie "IO."? Auch könnte man "startprogram" mit sowas wie "Tasks." oder "Program." zusammenfassen und dann noch diverse Befehle wie beenden von Programmen hinzufügen.

      Aber soviel sei gesagt: Dein Projekt hat wirklich potenzial. Mit einer/mehreren Personen zusätzlich an Bord könnte man dein Projekt wirklich ausbauen und man könnte es für viele Dinge benutzen. Die Arbeit bis zu dieser Version ist schon ganz ordentlich(vom äußeren her, den Code kann ich ja nicht beurteilen ^^ ). Wenn noch Dinge wie Variablen, If-Clauses, Select-Cases und so ein Zeug hinzugefügt wird, dann kann man es wirklich für gute Dinge benutzen. Naja soviel von mir. Mach weiter so!

      LG

      P.S.
      Übrigens hatte ich mal sowas ähnliches, ein Shell-Programm, das konnte Variablen. Ich habe es dort einfach mit einer Klasse gelöst in der ich eine List(of String) hatte inder ich dann die Variablen geschrieben habe bspw. "int;hallo|5". Mit einer Funktion zum Suchen habe ich dann die Variablen herausgeholt und mit anderen Methoden habe ich welche hinzugefügt, gelöscht und umbenannt. Vielleicht ist das ein erster Ansatz für dich? LG

      Danke für deine Rückmeldung. Ich sollte wirklich mal eine Anleitung schreiben. Den Bereich File umzubenennen ist keine schlechte Idee. Es ist wirklich leicht irritierend. Danke für den Tipp mit den Variablen!
      Alle Angaben sind ohne Gewähr, jedoch mit Pistole. Glücksspiel, Drogen und leckeres Essen können süchtig machen.

      43232069737420636f6f6c21

      Naja - so toll ist der Ansatz nun auch wieder nicht. Anstatt Strings solltest du anständige Datentypen verwenden.
      Aber erstmal solltest du überlegen, welche Datentypen du haben willst - ich würde Boolean, String & Number empfehlen (also Ja/Nein, Zeichenfolge und Zahl). Damit lässt sich das meiste abdecken. Dann musst du überlegen, welche "Namen" Variablen haben können (z.B. B1-B999 für Booleans usw. oder ganz normale Namen, ...). Dann gibt es einen ganz einfachen Ansatz: du erstellst ein Dictionary(Of String, Variable), wo der String den Namen beschreibt und die Klasse Variable den Wert und den Typ des Wertes abspeichern. Zuletzt musst bei jedem Zugriff auf die Variable prüfen, ob sie deklariert ist und schauen, ob der Typ mit dem abgefragten/zugewiesenen Typ übereinstimmt. Dann hast du ein verhältnismäßig einfaches System für Variablen.


      (Sorry für den Doppelpost, will aber unbedingt noch was los werden)
      Hab mir mal den Source angeschaut - hoffe du hast nix dagegen. So wie dein "Interpreter" momentan aufgebaut ist (Hardgecodete Abfrage für jede Funktion) wird das nix. Der Aufbau sollte eher so sein:
      -Tokenizer zerlegt Datei in Tokens (Werte, Funktionsaufrufe, ...)
      -Du suchst die Funktionsaufrufe raus und holst aus einer zentralen Klasse die zugehörigen Funktionen raus
      -Ausführung des Codes

      Doppelpost zusammengefügt. Für nachträgliche Ergänzungen gibt es die 'Bearbeiten'-Funktion! ~Thunderbolt

      Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von „nafets“ ()

      Hi,
      ich würde dir empfehlen, das Programm sofort auf Github (o. ä.) hochzuladen, denn wenn du mit dem Aufbau der Sprache falsch anfängst, kannst du zum Schluss alles übern Haufen werfen. Vielleicht wäre eine kleine IDE ganz gut, denn so simpel, wie die Sprache ist, wird das bestimmt nicht viel Arbeit in Anspruch nehmen. (Quasi den Windows Editor kopieren, gescheites Syntaxhighlighting einbauen und vielleicht noch eine Autovervollständigung, und natürlich den automatischen Header nicht vergessen. Sonst könnte man sogar eine Fehlerbehandlung (Syntaxfehler) einbauen, obwohl das wohl etwas länger dauern würde)
      Mfg
      Vincent

      Man braucht mMn dafür keine extra gecodete IDE. Es geht dabei ja hauptsächlich um die Übersichtlichkeit des Codes. Meines Wissens nach, kann man bspw. in Notepad++ die eigene Syntax reinschreiben und die entsprechende Datei exportieren. So etwas dauert vielleicht ein oder zwei Stunden zu schreiben und man muss nicht noch ein Programm schreiben. So etwas reicht doch erstmal zumal der Umfang noch relativ gering ist.

      LG

      @ChOoSeMyNaMe
      Sehe ich ehrlich gesagt genau anders rum: Wenn diese Sprache eine ordentlich IDE hätte, die man leicht bedienen kann, mit Syntaxhightlighting und einer IntelliSense, dann würde ich mir das eher angucken. Mir wäre der Aufwand zu groß, mir jetzt anzugucken, wie das geht, was man beachten muss, was nicht geht und wo die Fehler sind. Gäbe es aber eine IDE, die mir den Header generiert und sagt, wenn irgendwo ein Syntaxfehler ist, dann wäre es wesentlich unkomplizierter. Abgesehen davon soll diese Sprache doch Leute ansprechen, die, sorry, keine Ahnung haben und einfach nur ein schnelles Script schreiben wollen, um irgendeine Aufgabe zu erledigen. Um schnell etwas zu erledigen gibt es mehrer Faktoren: Die Sprache muss einfach gestaltet sein, sodass man nicht dauernd in irgendeiner Dokumentation nachgucken muss, sondern sich das schon denken kann, und möglichst kurz gehalten, sodass man für das einfache kopieren keine hundert Zeile Code braucht. Das wurde ja schon ganz gut erfüllt. Jetzt will ich aber auch schnell starten können. Dafür müsste ich momentan den Header auswendig lernen oder ihn jedes mal kopieren -> mit VB.Net würde es schneller gehen -> der Sinn wurde nicht ganz erfüllt. Außerdem werden Fehler erst erkannt, wenn ich das ganze ausführe und eine Autovervollständigung, die den Punkt "einfach zu merken" noch schneller macht, gibt es auch nicht.
      Mfg
      Vincent

      Da hier so ein Interesse herrscht, werde ich es wahrscheinlich Open Source machen. Ich kenne mich zwar mit Github kaum aus, aber dass krieg ich schon irgendwie hin. Leider werde ich erst nächstes Wochenende dazu kommen. Bis dahin bin ich schlecht erreichbar.

      Danke für eure Unterstützung!
      Alle Angaben sind ohne Gewähr, jedoch mit Pistole. Glücksspiel, Drogen und leckeres Essen können süchtig machen.

      43232069737420636f6f6c21

      Mal sehen. Ich bin jetzt bis Freitagnachmittag im Internat und kann nicht an meinen PC. Bis dahin komme ich an meine Projektdaten nicht ran.
      @ErfinderDesRades noch nicht, aber wir sind ja erst am Anfang.
      Alle Angaben sind ohne Gewähr, jedoch mit Pistole. Glücksspiel, Drogen und leckeres Essen können süchtig machen.

      43232069737420636f6f6c21

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

      Ich hab mal die aktuellste Version des Tokenizers, den ich bei meinen Projekten verwende:
      C#

      C#-Quellcode

      1. using System;
      2. using System.Collections.Generic;
      3. using System.IO;
      4. using System.Linq;
      5. using System.Text;
      6. using System.Threading.Tasks;
      8. namespace SimpleScript.Tokenizer
      9. {
      10. public class Tokenizer
      11. {
      12. public Tokenizer(string code)
      13. {
      14. this.IgnoreWhitespace = false;
      15. this.SymbolCharacters = "=+-/,.*~!@#$%^&(){}[]:;<>?|\\".ToList();
      16. this.DecimalSeperator = '.';
      17. this.currentLine = 1;
      18. this.currentColumn = 1;
      19. this.currentPosTotal = 0;
      20. this.inputCode = code;
      21. }
      23. private const char EndOfFile = (char)0;
      25. protected string inputCode { get; private set; }
      26. protected int tokenStartLine { get; set; }
      27. protected int tokenStartColumn { get; set; }
      28. protected int tokenStartPosTotal { get; set; }
      29. protected int currentLine { get; set; }
      30. protected int currentColumn { get; set; }
      31. protected int currentPosTotal { get; set; }
      33. public bool IgnoreWhitespace { get; set; }
      34. public List<char> SymbolCharacters { get; set; }
      35. public char DecimalSeperator { get; set; }
      37. public bool TryGetToken(out Token token)
      38. {
      39. char cCurrent = this.LookAhead();
      41. switch (cCurrent)
      42. {
      43. case EndOfFile:
      44. this.StartToken();
      45. token = this.CreateToken(TokenType.EndOfFile);
      46. return false;
      47. case ' ':
      48. case '\t':
      49. if (this.IgnoreWhitespace)
      50. {
      51. this.MoveForward();
      52. return this.TryGetToken(out token);
      53. }
      54. token = this.ReadWhitespace();
      55. break;
      56. case '\r':
      57. case '\n':
      58. token = this.ReadNewLine();
      59. break;
      60. case '"':
      61. token = this.ReadQuotedString();
      62. break;
      63. default:
      64. if (char.IsNumber(cCurrent) || cCurrent == '-')
      65. {
      66. token = this.ReadNumber();
      67. }
      68. else if (char.IsLetter(cCurrent) || cCurrent == '_')
      69. {
      70. token = this.ReadWord();
      71. }
      72. else
      73. {
      74. this.StartToken();
      75. this.MoveForward();
      76. token = this.CreateToken(this.SymbolCharacters.Contains(cCurrent) ? TokenType.Symbol : TokenType.Unknown);
      77. }
      78. break;
      79. }
      81. return true;
      82. }
      84. public IEnumerable<Token> GetTokens()
      85. {
      86. Token currentToken;
      87. while (TryGetToken(out currentToken))
      88. {
      89. yield return currentToken;
      90. }
      92. yield return currentToken;
      93. yield break;
      94. }
      96. protected char LookAhead(int count = 1)
      97. {
      98. if (this.currentPosTotal + count - 1 >= this.inputCode.Length)
      99. {
      100. return EndOfFile;
      101. }
      102. return this.inputCode[this.currentPosTotal + count - 1];
      103. }
      105. protected void MoveForward()
      106. {
      107. this.currentPosTotal++;
      108. this.currentColumn++;
      109. }
      111. protected Token CreateToken(string value, TokenType type = TokenType.Unknown)
      112. {
      113. return new Token(this.currentLine, this.currentColumn, value, type);
      114. }
      116. protected Token CreateToken(TokenType type = TokenType.Unknown)
      117. {
      118. return new Token(this.tokenStartLine, this.tokenStartColumn, this.inputCode.Substring(this.tokenStartPosTotal, this.currentPosTotal - this.tokenStartPosTotal), type);
      119. }
      121. protected void StartToken()
      122. {
      123. this.tokenStartColumn = this.currentColumn;
      124. this.tokenStartLine = this.currentLine;
      125. this.tokenStartPosTotal = this.currentPosTotal;
      126. }
      128. protected Token ReadNewLine()
      129. {
      130. this.StartToken();
      131. if (this.LookAhead() == '\r' && this.LookAhead(2) == '\n')
      132. this.MoveForward();
      133. this.MoveForward();
      135. this.currentLine++;
      136. this.currentColumn = 1;
      138. return this.CreateToken(TokenType.EndOfLine);
      139. }
      141. protected Token ReadWhitespace()
      142. {
      143. this.StartToken();
      144. this.MoveForward();
      146. char cCurrent = this.LookAhead();
      147. while ((cCurrent == '\t' || cCurrent == ' ' ) && cCurrent != EndOfFile)
      148. {
      149. this.MoveForward();
      150. cCurrent = this.LookAhead();
      151. }
      152. return this.CreateToken(TokenType.WhiteSpace);
      153. }
      155. protected Token ReadWord()
      156. {
      157. this.StartToken();
      158. this.MoveForward();
      160. char cCurrent = this.LookAhead();
      161. while (((!char.IsWhiteSpace(cCurrent) && !this.SymbolCharacters.Contains(cCurrent))) && cCurrent != EndOfFile)
      162. {
      163. this.MoveForward();
      164. cCurrent = this.LookAhead();
      165. }
      166. return this.CreateToken(TokenType.Word);
      167. }
      169. protected Token ReadQuotedString()
      170. {
      171. this.StartToken();
      172. this.MoveForward();
      174. char cCurrent = this.LookAhead();
      175. while (cCurrent != EndOfFile)
      176. {
      177. switch (cCurrent)
      178. {
      179. case '\r':
      180. this.MoveForward();
      181. if (this.LookAhead() == '\n') this.MoveForward(); //Handle \r\n (CrLf)
      183. this.currentLine++;
      184. this.currentColumn = 1;
      186. break;
      187. case '\n':
      188. this.MoveForward();
      189. this.currentLine++;
      190. this.currentColumn = 1;
      192. break;
      193. case '"':
      194. this.MoveForward();
      196. if (this.LookAhead() != '"')
      197. {
      198. return this.CreateToken(TokenType.QuotedString);
      199. }
      201. this.MoveForward(); //Escaped Quote (Double Quote like in Visual Basic)
      203. break;
      204. default:
      205. this.MoveForward();
      206. break;
      207. }
      209. cCurrent = this.LookAhead();
      210. }
      212. return this.CreateToken(TokenType.Unknown);
      213. }
      215. protected Token ReadNumber()
      216. {
      217. this.StartToken();
      218. this.MoveForward();
      220. char cCurrent = this.LookAhead();
      221. bool hasDecimalSeperator = false;
      223. if (cCurrent == '-') this.MoveForward();
      224. while ((char.IsNumber(cCurrent) || (!hasDecimalSeperator && (hasDecimalSeperator = (cCurrent == this.DecimalSeperator)))) && cCurrent != EndOfFile)
      225. {
      226. this.MoveForward();
      227. cCurrent = this.LookAhead();
      228. }
      229. return this.CreateToken(TokenType.Number);
      230. }
      231. }
      232. }

      C#-Quellcode

      1. public class Token
      2. {
      3. public Token(int line, int column, string value, TokenType type)
      4. {
      5. this.Line = line;
      6. this.Column = column;
      7. this.Value = value;
      8. this.Type = type;
      9. }
      11. public int Line { get; private set; }
      12. public int Column { get; private set; }
      13. public string Value { get; private set; }
      14. public TokenType Type { get; private set; }
      16. public override string ToString()
      17. {
      18. return string.Format("{{Value: \"{0}\" Type: {1} (Line {2}, Column {3})}}", this.Value, this.Type, this.Line, this.Column);
      19. }
      20. }

      C#-Quellcode

      1. public enum TokenType
      2. {
      3. Unknown,
      4. Word,
      5. Number,
      6. QuotedString,
      7. WhiteSpace,
      8. Symbol,
      9. EndOfLine,
      10. EndOfFile
      11. }

      VB (über Converter)

      VB.NET-Quellcode

      1. Imports System.Collections.Generic
      2. Imports System.IO
      3. Imports System.Linq
      4. Imports System.Text
      5. Imports System.Threading.Tasks
      7. Namespace SimpleScript.Tokenizer
      8. Public Class Tokenizer
      9. Public Sub New(code As String)
      10. Me.IgnoreWhitespace = False
      11. Me.SymbolCharacters = "=+-/,.*~!@#$%^&(){}[]:;<>?|\".ToList()
      12. Me.DecimalSeperator = "."C
      13. Me.currentLine = 1
      14. Me.currentColumn = 1
      15. Me.currentPosTotal = 0
      16. Me.inputCode = code
      17. End Sub
      19. Private Const EndOfFile As Char = ChrW(0)
      21. Protected Property inputCode() As String
      22. Get
      23. Return m_inputCode
      24. End Get
      25. Private Set
      26. m_inputCode = Value
      27. End Set
      28. End Property
      29. Private m_inputCode As String
      30. Protected Property tokenStartLine() As Integer
      31. Get
      32. Return m_tokenStartLine
      33. End Get
      34. Set
      35. m_tokenStartLine = Value
      36. End Set
      37. End Property
      38. Private m_tokenStartLine As Integer
      39. Protected Property tokenStartColumn() As Integer
      40. Get
      41. Return m_tokenStartColumn
      42. End Get
      43. Set
      44. m_tokenStartColumn = Value
      45. End Set
      46. End Property
      47. Private m_tokenStartColumn As Integer
      48. Protected Property tokenStartPosTotal() As Integer
      49. Get
      50. Return m_tokenStartPosTotal
      51. End Get
      52. Set
      53. m_tokenStartPosTotal = Value
      54. End Set
      55. End Property
      56. Private m_tokenStartPosTotal As Integer
      57. Protected Property currentLine() As Integer
      58. Get
      59. Return m_currentLine
      60. End Get
      61. Set
      62. m_currentLine = Value
      63. End Set
      64. End Property
      65. Private m_currentLine As Integer
      66. Protected Property currentColumn() As Integer
      67. Get
      68. Return m_currentColumn
      69. End Get
      70. Set
      71. m_currentColumn = Value
      72. End Set
      73. End Property
      74. Private m_currentColumn As Integer
      75. Protected Property currentPosTotal() As Integer
      76. Get
      77. Return m_currentPosTotal
      78. End Get
      79. Set
      80. m_currentPosTotal = Value
      81. End Set
      82. End Property
      83. Private m_currentPosTotal As Integer
      85. Public Property IgnoreWhitespace() As Boolean
      86. Get
      87. Return m_IgnoreWhitespace
      88. End Get
      89. Set
      90. m_IgnoreWhitespace = Value
      91. End Set
      92. End Property
      93. Private m_IgnoreWhitespace As Boolean
      94. Public Property SymbolCharacters() As List(Of Char)
      95. Get
      96. Return m_SymbolCharacters
      97. End Get
      98. Set
      99. m_SymbolCharacters = Value
      100. End Set
      101. End Property
      102. Private m_SymbolCharacters As List(Of Char)
      103. Public Property DecimalSeperator() As Char
      104. Get
      105. Return m_DecimalSeperator
      106. End Get
      107. Set
      108. m_DecimalSeperator = Value
      109. End Set
      110. End Property
      111. Private m_DecimalSeperator As Char
      113. Public Function TryGetToken(ByRef token As Token) As Boolean
      114. Dim cCurrent As Char = Me.LookAhead()
      116. Select Case cCurrent
      117. Case EndOfFile
      118. Me.StartToken()
      119. token = Me.CreateToken(TokenType.EndOfFile)
      120. Return False
      121. Case " "C, ControlChars.Tab
      122. If Me.IgnoreWhitespace Then
      123. Me.MoveForward()
      124. Return Me.TryGetToken(token)
      125. End If
      126. token = Me.ReadWhitespace()
      127. Exit Select
      128. Case ControlChars.Cr, ControlChars.Lf
      129. token = Me.ReadNewLine()
      130. Exit Select
      131. Case """"C
      132. token = Me.ReadQuotedString()
      133. Exit Select
      134. Case Else
      135. If Char.IsNumber(cCurrent) OrElse cCurrent = "-"C Then
      136. token = Me.ReadNumber()
      137. ElseIf Char.IsLetter(cCurrent) OrElse cCurrent = "_"C Then
      138. token = Me.ReadWord()
      139. Else
      140. Me.StartToken()
      141. Me.MoveForward()
      142. token = Me.CreateToken(If(Me.SymbolCharacters.Contains(cCurrent), TokenType.Symbol, TokenType.Unknown))
      143. End If
      144. Exit Select
      145. End Select
      147. Return True
      148. End Function
      150. Public Function GetTokens() As IEnumerable(Of Token)
      151. Dim currentToken As Token
      152. While TryGetToken(currentToken)
      153. yield Return currentToken
      154. End While
      156. yield Return currentToken
      157. yield Exit Function
      158. End Function
      160. Protected Function LookAhead(Optional count As Integer = 1) As Char
      161. If Me.currentPosTotal + count - 1 >= Me.inputCode.Length Then
      162. Return EndOfFile
      163. End If
      164. Return Me.inputCode(Me.currentPosTotal + count - 1)
      165. End Function
      167. Protected Sub MoveForward()
      168. Me.currentPosTotal += 1
      169. Me.currentColumn += 1
      170. End Sub
      172. Protected Function CreateToken(value As String, Optional type As TokenType = TokenType.Unknown) As Token
      173. Return New Token(Me.currentLine, Me.currentColumn, value, type)
      174. End Function
      176. Protected Function CreateToken(Optional type As TokenType = TokenType.Unknown) As Token
      177. Return New Token(Me.tokenStartLine, Me.tokenStartColumn, Me.inputCode.Substring(Me.tokenStartPosTotal, Me.currentPosTotal - Me.tokenStartPosTotal), type)
      178. End Function
      180. Protected Sub StartToken()
      181. Me.tokenStartColumn = Me.currentColumn
      182. Me.tokenStartLine = Me.currentLine
      183. Me.tokenStartPosTotal = Me.currentPosTotal
      184. End Sub
      186. Protected Function ReadNewLine() As Token
      187. Me.StartToken()
      188. If Me.LookAhead() = ControlChars.Cr AndAlso Me.LookAhead(2) = ControlChars.Lf Then
      189. Me.MoveForward()
      190. End If
      191. Me.MoveForward()
      193. Me.currentLine += 1
      194. Me.currentColumn = 1
      196. Return Me.CreateToken(TokenType.EndOfLine)
      197. End Function
      199. Protected Function ReadWhitespace() As Token
      200. Me.StartToken()
      201. Me.MoveForward()
      203. Dim cCurrent As Char = Me.LookAhead()
      204. While (cCurrent = ControlChars.Tab OrElse cCurrent = " "C) AndAlso cCurrent <> EndOfFile
      205. Me.MoveForward()
      206. cCurrent = Me.LookAhead()
      207. End While
      208. Return Me.CreateToken(TokenType.WhiteSpace)
      209. End Function
      211. Protected Function ReadWord() As Token
      212. Me.StartToken()
      213. Me.MoveForward()
      215. Dim cCurrent As Char = Me.LookAhead()
      216. While ((Not Char.IsWhiteSpace(cCurrent) AndAlso Not Me.SymbolCharacters.Contains(cCurrent))) AndAlso cCurrent <> EndOfFile
      217. Me.MoveForward()
      218. cCurrent = Me.LookAhead()
      219. End While
      220. Return Me.CreateToken(TokenType.Word)
      221. End Function
      223. Protected Function ReadQuotedString() As Token
      224. Me.StartToken()
      225. Me.MoveForward()
      227. Dim cCurrent As Char = Me.LookAhead()
      228. While cCurrent <> EndOfFile
      229. Select Case cCurrent
      230. Case ControlChars.Cr
      231. Me.MoveForward()
      232. If Me.LookAhead() = ControlChars.Lf Then
      233. Me.MoveForward()
      234. End If
      235. 'Handle \r\n (CrLf)
      236. Me.currentLine += 1
      237. Me.currentColumn = 1
      239. Exit Select
      240. Case ControlChars.Lf
      241. Me.MoveForward()
      242. Me.currentLine += 1
      243. Me.currentColumn = 1
      245. Exit Select
      246. Case """"C
      247. Me.MoveForward()
      249. If Me.LookAhead() <> """"C Then
      250. Return Me.CreateToken(TokenType.QuotedString)
      251. End If
      253. Me.MoveForward()
      254. 'Escaped Quote (Double Quote like in Visual Basic)
      255. Exit Select
      256. Case Else
      257. Me.MoveForward()
      258. Exit Select
      259. End Select
      261. cCurrent = Me.LookAhead()
      262. End While
      264. Return Me.CreateToken(TokenType.Unknown)
      265. End Function
      267. Protected Function ReadNumber() As Token
      268. Me.StartToken()
      269. Me.MoveForward()
      271. Dim cCurrent As Char = Me.LookAhead()
      272. Dim hasDecimalSeperator As Boolean = False
      274. If cCurrent = "-"C Then
      275. Me.MoveForward()
      276. End If
      277. While (Char.IsNumber(cCurrent) OrElse (Not hasDecimalSeperator AndAlso (InlineAssignHelper(hasDecimalSeperator, (cCurrent = Me.DecimalSeperator))))) AndAlso cCurrent <> EndOfFile
      278. Me.MoveForward()
      279. cCurrent = Me.LookAhead()
      280. End While
      281. Return Me.CreateToken(TokenType.Number)
      282. End Function
      283. Private Shared Function InlineAssignHelper(Of T)(ByRef target As T, value As T) As T
      284. target = value
      285. Return value
      286. End Function
      287. End Class
      288. End Namespace

      VB.NET-Quellcode

      1. Public Class Token
      2. Public Sub New(line As Integer, column As Integer, value As String, type As TokenType)
      3. Me.Line = line
      4. Me.Column = column
      5. Me.Value = value
      6. Me.Type = type
      7. End Sub
      9. Public Property Line() As Integer
      10. Get
      11. Return m_Line
      12. End Get
      13. Private Set
      14. m_Line = Value
      15. End Set
      16. End Property
      17. Private m_Line As Integer
      18. Public Property Column() As Integer
      19. Get
      20. Return m_Column
      21. End Get
      22. Private Set
      23. m_Column = Value
      24. End Set
      25. End Property
      26. Private m_Column As Integer
      27. Public Property Value() As String
      28. Get
      29. Return m_Value
      30. End Get
      31. Private Set
      32. m_Value = Value
      33. End Set
      34. End Property
      35. Private m_Value As String
      36. Public Property Type() As TokenType
      37. Get
      38. Return m_Type
      39. End Get
      40. Private Set
      41. m_Type = Value
      42. End Set
      43. End Property
      44. Private m_Type As TokenType
      46. Public Overrides Function ToString() As String
      47. Return String.Format("{{Value: ""{0}"" Type: {1} (Line {2}, Column {3})}}", Me.Value, Me.Type, Me.Line, Me.Column)
      48. End Function
      49. End Class

      VB.NET-Quellcode

      1. Public Enum TokenType
      2. Unknown
      3. Word
      4. Number
      5. QuotedString
      6. WhiteSpace
      7. Symbol
      8. EndOfLine
      9. EndOfFile
      10. End Enum

      Der Code ist übrigens stark an den des StringTokenizer angelehnt.

      Hoffentlich hilft dir das bei der Entwicklung einer von der Technik her etwas fortgeschritteneren Version deiner Skriptsprache. An sich finde ich die Idee ja eigentlich ganz gut.

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

      Find die Idee eigentlich gar nicht so schlecht, jedoch ist der name ein bisschen doof? (Wie wärs was mit ...Script hintendran a la WindowsScript?) Was bestimmt noch cool wäre, wenn man sowas machen könnte:

      Quellcode

      1. text.setPauseText: Press any key...


      würde jedenfalls das gedusel im Code erheblich bessern. Außerdem sowas wie functions einfügen? Ist eigentlich gar nicht so schwer:

      Quellcode

      1. function Bla() {
      2. // code here...
      3. }


      Übersetzter Code:

      C#-Quellcode

      1. void Bla() {
      2. // code here..
      3. }


      müsstest nur function zu void übersetzen.

      EDIT:

      Hab übrigens mal hier was in Python probiert, vielleicht hilft es ja weiter ;):

      Quellcode

      1. #!/usr/bin/env python
      3. import fileinput
      5. if __name__ == '__main__':
      6. for line in fileinput.input('datei.script', inplace=True):
      7. print(line.replace('function', 'void'), end='')

      Software being "Done" is like lawn being "Mowed". (Jim Benson)

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „KidRick“ ()

      @KidRick

      Meines Wissens ist sowas nicht mal schnell so zu bewerkstelligen. Dafür braucht man Klassen, die das ganze dann allgemein bzw. dynamisch durchgehen. Es einfach in einen C#-Code zu übersetzen (zu mal das ganze in VB.Net geschrieben ist ^^ ), ist mMn der falsche Ansatz, und ich denke, dass das überhaupt nicht funktioniert.. Außerdem sollte man sich erstmal an elementare Dinge setzen: Variablen und If-Clauses. Ohne die würden Methoden noch garkeinen Sinn machen.

      LG