ScriptStack.Runtime.Script Class Reference

Internal representation of a text file (source code) which can be passed to the Interpreter to execute it. More...

Public Member Functions
	Script (Manager manager, string scriptName)
	Script (Manager manager, string scriptName, bool binary)
void	CompileBinary (string fileName)
void	CompileJSON (string fileName)
bool	EntryPoint ()

Properties
Manager	Manager [get]
string	Name [get]
ReadOnlyCollection< String >	SourceLines [get]
string	Source [get]
Executable	Executable [get]
Memory	ScriptMemory [get]
ScriptStack.Collections.ReadOnlyDictionary< String, Function >	Functions [get]
Function	MainFunction [get]

Private Member Functions
void	Scan (string scriptName)

Static Private Member Functions
static object	ConvertLexeme (SerializableToken st)
static object	ConvertLexeme (TokenType type, string lexemeStr)

Private Attributes
Manager	manager
String	scriptName
List< String >	sourceCode
Executable	executable

Detailed Description

Internal representation of a text file (source code) which can be passed to the Interpreter to execute it.

Definition at line 17 of file Script.cs.

Constructor & Destructor Documentation

Script() [1/2]

ScriptStack.Runtime.Script.Script	(	Manager	manager,
		string	scriptName )

Definition at line 219 of file Script.cs.

        {
 
            this.manager = manager;
 
            this.scriptName = scriptName;
 
            try
            {
 
                Scan(scriptName);
 
                //Lexer lexer = new Lexer(sourceCode);
                Lexer lexer = manager.LexerFactory(sourceCode);
 
                List<Token> tokenStream = lexer.GetTokens();
 
                Parser parser = new Parser(this, tokenStream);
 
                parser.DebugMode = this.manager.Debug;
 
                executable = parser.Parse();
 
                if (this.manager.Optimize)
                {
 
                    Optimizer optimizer = new Optimizer(executable);
 
                    optimizer.OptimizerInfo = false;
 
                    optimizer.Optimize();
 
                }
 
 
            }
            catch (Exception exception)
            {
                throw new ScriptStackException("Fehler in '" + scriptName + "'.", exception);
            }
 
        }

References ScriptStack.Manager.Debug, executable, ScriptStack.Compiler.Lexer.GetTokens(), Manager, manager, ScriptStack.Manager.Optimize, ScriptStack.Compiler.Parser.Parse(), Scan(), scriptName, and sourceCode.

Script() [2/2]

ScriptStack.Runtime.Script.Script	(	Manager	manager,
		string	scriptName,
		bool	binary )

Definition at line 262 of file Script.cs.

        {
 
            this.manager = manager;
 
            this.scriptName = scriptName;
 
            try
            {
 
                List<Token> tokenStream = null;
                if (binary == true)
                {
                    tokenStream = new List<Token>();
                    using (var fs = new FileStream(scriptName, FileMode.Open, FileAccess.Read))
                    using (var br = new BinaryReader(fs))
                    {
                        int count = br.ReadInt32();
 
                        for (int i = 0; i < count; i++)
                        {
                            var typeInt = br.ReadInt32();
                            var lexemeStr = br.ReadString();
                            var line = br.ReadInt32();
                            var column = br.ReadInt32();
                            var text = ""; // br.ReadString();
 
                            TokenType type = (TokenType)typeInt;
                            object lexeme = ConvertLexeme(type, lexemeStr);
 
                            tokenStream.Add(new Token(type, lexeme, line, column, text));
                        }
                    }
                }
                else
                {
                    string json = File.ReadAllText(scriptName, Encoding.UTF8);
 
                    var serializableTokens = JsonSerializer.Deserialize<List<SerializableToken>>(json);
 
                    // Falls du wieder echte Token-Objekte brauchst:
                    tokenStream = serializableTokens
                        .Select(st => new Token(
                            st.Type,
                            ConvertLexeme(st),   // (st.Lexeme) oder hier wieder in int/float/etc. umwandeln, wenn nötig
                            st.Line,
                            st.Column,
                            st.Text))
                        .ToList();
                } 
 
                Parser parser = new Parser(this, tokenStream);
 
                parser.DebugMode = this.manager.Debug;
 
                executable = parser.Parse();
 
 
                if (this.manager.Optimize)
                {
 
                    Optimizer optimizer = new Optimizer(executable);
 
                    optimizer.OptimizerInfo = false;
 
                    optimizer.Optimize();
 
                }
 
 
            }
            catch (Exception exception)
            {
                throw new ScriptStackException("Fehler in '" + scriptName + "'.", exception);
            }
 
        }

References ConvertLexeme(), ScriptStack.Manager.Debug, executable, Manager, manager, ScriptStack.Manager.Optimize, ScriptStack.Compiler.Parser.Parse(), and scriptName.

Member Function Documentation

CompileBinary()

void ScriptStack.Runtime.Script.CompileBinary

(

string

fileName

)

Definition at line 340 of file Script.cs.

        {
 
            try
            {
 
                Scan(scriptName);
 
                Lexer lexer = new Lexer(sourceCode);
 
                List<Token> tokenStream = lexer.GetTokens();
 
                using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write))
                using (var bw = new BinaryWriter(fs))
                {
                    // Anzahl Tokens zuerst
                    bw.Write(tokenStream.Count);
 
                    foreach (var t in tokenStream)
                    {
                        bw.Write((int)t.Type);         // Enum als int
                        bw.Write(t.Lexeme?.ToString() ?? ""); // als String
                        bw.Write(t.Line);
                        bw.Write(t.Column);
                        //bw.Write(t.Text ?? "");
                    }
                }
 
            }
            catch (Exception exception)
            {
                throw new ScriptStackException("Fehler in '" + scriptName + "'.", exception);
            }
        }

References ScriptStack.Compiler.Lexer.GetTokens(), Scan(), scriptName, and sourceCode.

CompileJSON()

void ScriptStack.Runtime.Script.CompileJSON

(

string

fileName

)

Definition at line 375 of file Script.cs.

        {
 
            try
            {
 
                Scan(scriptName);
 
                Lexer lexer = new Lexer(sourceCode);
 
                List<Token> tokenStream = lexer.GetTokens();
 
                var serializableTokens = tokenStream.Select(t => new SerializableToken
                {
                    Type = t.Type,
                    Lexeme = t.Lexeme?.ToString(),
                    Line = t.Line,
                    Column = t.Column,
                    Text = t.Text
                }).ToList();
 
                var options = new JsonSerializerOptions
                {
                    WriteIndented = true // für schön formatiertes JSON
                };
 
                string json = JsonSerializer.Serialize(serializableTokens, options);
 
                // In Datei schreiben
                File.WriteAllText(fileName, json, Encoding.UTF8);
 
            }
            catch (Exception exception)
            {
                throw new ScriptStackException("Fehler in '" + scriptName + "'.", exception);
            }
        }

References ScriptStack.Compiler.Lexer.GetTokens(), Scan(), scriptName, and sourceCode.

ConvertLexeme() [1/2]

object ScriptStack.Runtime.Script.ConvertLexeme ( SerializableToken st )

staticprivate

Definition at line 102 of file Script.cs.

        {
            if (st.Lexeme == null)
                return null;
 
            // Je nach TokenType anders parsen
            switch (st.Type)
            {
                case TokenType.Integer:
                    // z.B. "42" -> 42
                    return int.Parse(st.Lexeme, CultureInfo.InvariantCulture);
 
                case TokenType.Float:
                    // z.B. "3.14" -> 3.14f
                    return float.Parse(st.Lexeme, CultureInfo.InvariantCulture);
 
                case TokenType.Double:
                    // z.B. "3.14159" -> 3.14159d
                    return double.Parse(st.Lexeme, CultureInfo.InvariantCulture);
 
                case TokenType.Boolean:
                    // "true" / "false"
                    return bool.Parse(st.Lexeme);
 
                case TokenType.Char:
                    // hängt davon ab, wie dein Lexer das Lexeme speichert
                    // Beispiel 1: nur das Zeichen selbst: "a"
                    if (st.Lexeme.Length == 1)
                        return st.Lexeme[0];
 
                    // Beispiel 2: inklusive Hochkommas: "'a'"
                    if (st.Lexeme.Length >= 3 &&
                        st.Lexeme[0] == '\'' &&
                        st.Lexeme[^1] == '\'')
                    {
                        return st.Lexeme[1];
                    }
 
                    throw new FormatException($"Ungültiges Char-Lexeme: '{st.Lexeme}'");
 
                case TokenType.Null:
                    // für 'null' kannst du einfach null zurückgeben
                    return null;
 
                case TokenType.String:
                    // hier kannst du entscheiden:
                    // - komplette Literal-Syntax behalten ("\"Hallo\"")
                    // - oder die Anführungszeichen entfernen, wenn dein Lexer sie drin hat
                    // Beispiel: Anführungszeichen entfernen:
                    if (st.Lexeme.Length >= 2 &&
                        st.Lexeme[0] == '"' &&
                        st.Lexeme[^1] == '"')
                    {
                        return st.Lexeme.Substring(1, st.Lexeme.Length - 2);
                    }
                    return st.Lexeme;
 
                default:
                    // für alles andere reicht der String
                    return st.Lexeme;
            }
        }

References ScriptStack.Compiler.SerializableToken.Lexeme, and ScriptStack.Compiler.SerializableToken.Type.

Referenced by Script().

ConvertLexeme() [2/2]

object ScriptStack.Runtime.Script.ConvertLexeme ( TokenType type, string lexemeStr )

staticprivate

Definition at line 165 of file Script.cs.

        {
            // Falls du für Null-Tokens z.B. ein leeres Lexeme speicherst:
            if (type == TokenType.Null)
                return null;
 
            if (lexemeStr == null)
                return null;
 
            switch (type)
            {
                case TokenType.Integer:
                    return int.Parse(lexemeStr, CultureInfo.InvariantCulture);
 
                case TokenType.Float:
                    return float.Parse(lexemeStr, CultureInfo.InvariantCulture);
 
                case TokenType.Double:
                    return double.Parse(lexemeStr, CultureInfo.InvariantCulture);
 
                case TokenType.Boolean:
                    return bool.Parse(lexemeStr);
 
                case TokenType.Char:
                    // Variante 1: nur das Zeichen selbst gespeichert, z.B. "a"
                    if (lexemeStr.Length == 1)
                        return lexemeStr[0];
 
                    // Variante 2: inkl. Hochkommas, z.B. "'a'"
                    if (lexemeStr.Length >= 3 &&
                        lexemeStr[0] == '\'' &&
                        lexemeStr[^1] == '\'')
                    {
                        return lexemeStr[1];
                    }
 
                    throw new FormatException($"Ungültiges Char-Lexeme: '{lexemeStr}'");
 
                case TokenType.String:
                    // Wenn dein Lexer die Anführungszeichen mit speichert ("\"Hallo\"")
                    if (lexemeStr.Length >= 2 &&
                        lexemeStr[0] == '"' &&
                        lexemeStr[^1] == '"')
                    {
                        return lexemeStr.Substring(1, lexemeStr.Length - 2);
                    }
                    return lexemeStr;
 
                default:
                    // Für alles andere reicht der String
                    return lexemeStr;
            }
        }

EntryPoint()

bool ScriptStack.Runtime.Script.EntryPoint

(

)

Definition at line 413 of file Script.cs.

        {
            return executable.FunctionExists("main");
        }

References executable.

Scan()

void ScriptStack.Runtime.Script.Scan ( string scriptName )

private

Definition at line 31 of file Script.cs.

        {
 
            Scanner scanner = manager.Scanner;
            sourceCode = scanner.Scan(scriptName);
            sourceCode.Add(" ");
 
            Dictionary<string, bool> included = new Dictionary<string, bool>();
 
            for (int i = 0; i < sourceCode.Count; i++)
            {
 
                string line = sourceCode[i];
 
                Lexer lexer = new Lexer(new List<string> { line });
 
                List<Token> tokenStream = null;
 
                try
                {
                    tokenStream = lexer.GetTokens();
                }
                catch (Exception)
                {
                    continue;
                }
 
                if (tokenStream.Count == 0)
                    continue;
 
                if (tokenStream[0].Type != TokenType.Include)
                    continue;
 
                if (tokenStream.Count < 2)
                    throw new ParserException("Include Statement ohne Pfadangabe.");
 
                if (tokenStream[1].Type != TokenType.String)
                    throw new ParserException("Nach einem 'include' Befehl wird ein String (Pfad) erwartet.");
 
                if (tokenStream.Count < 3)
                    throw new ParserException("Semicolon ';' am Ende eines 'include' Statement erwartet.");
 
                if (tokenStream[2].Type != TokenType.SemiColon)
                    throw new ParserException("Semicolon ';' am Ende eines 'include' Statement erwartet.");
 
                if (tokenStream.Count > 3)
                    throw new ParserException("Es wird nichts nach dem Semicolon ';' am Ende eines 'include' Statement erwartet.");
 
                string include = (string)tokenStream[1].Lexeme;
 
                sourceCode.RemoveAt(i);
 
                if (included.ContainsKey(include))
                    continue;
 
                /* and place the source where the original include statement was.. */
                sourceCode.InsertRange(i, scanner.Scan(include));
 
                /* set the current script as already included */
                included[include] = true;
 
                --i;
 
            }
 
        }

References ScriptStack.Compiler.Lexer.GetTokens(), manager, ScriptStack.Compiler.Scanner.Scan(), scriptName, and sourceCode.

Referenced by CompileBinary(), CompileJSON(), and Script().

Member Data Documentation

executable

Executable ScriptStack.Runtime.Script.executable

private

Definition at line 25 of file Script.cs.

Referenced by EntryPoint(), Script(), and Script().

manager

Manager ScriptStack.Runtime.Script.manager

private

Definition at line 22 of file Script.cs.

Referenced by Scan(), Script(), and Script().

scriptName

String ScriptStack.Runtime.Script.scriptName

private

Definition at line 23 of file Script.cs.

Referenced by CompileBinary(), CompileJSON(), Scan(), Script(), and Script().

sourceCode

List<String> ScriptStack.Runtime.Script.sourceCode

private

Definition at line 24 of file Script.cs.

Referenced by CompileBinary(), CompileJSON(), Scan(), and Script().

Property Documentation

Executable

Executable ScriptStack.Runtime.Script.Executable

get

Definition at line 451 of file Script.cs.

        {
            get { return executable; }
        }

Functions

ScriptStack.Collections.ReadOnlyDictionary<String, Function> ScriptStack.Runtime.Script.Functions

get

Definition at line 461 of file Script.cs.

        {
            get
            {
                return new ScriptStack.Collections.ReadOnlyDictionary<String,Function>(executable.Functions);
            }
        }

MainFunction

Function ScriptStack.Runtime.Script.MainFunction

get

Definition at line 469 of file Script.cs.

        {
            get { return executable.MainFunction; }
        }

Manager

Manager ScriptStack.Runtime.Script.Manager

get

Definition at line 422 of file Script.cs.

        {
            get { return manager; }
        }

Referenced by Script(), and Script().

Name

string ScriptStack.Runtime.Script.Name

get

Definition at line 427 of file Script.cs.

        {
            get { return scriptName; }
        }

ScriptMemory

Memory ScriptStack.Runtime.Script.ScriptMemory

get

Definition at line 456 of file Script.cs.

        {
            get { return executable.ScriptMemory; }
        }

Source

string ScriptStack.Runtime.Script.Source

get

Definition at line 437 of file Script.cs.

        {
            get
            {
                StringBuilder sb = new StringBuilder();
                foreach (string line in sourceCode)
                {
                    sb.Append(line);
                    sb.Append("\r\n");
                }
                return sb.ToString();
            }
        }

SourceLines

ReadOnlyCollection<String> ScriptStack.Runtime.Script.SourceLines

get

Definition at line 432 of file Script.cs.

        {
            get { return sourceCode.AsReadOnly(); } 
        }

---

The documentation for this class was generated from the following file:

• Src/Runtime/Script.cs