The parser builds an ScriptStack.Runtime.Executable out of the Token stream returned from the ScriptStack.Compiler.Lexer while checking for correct syntax. Mehr ...

Klassen
struct	FunctionDescriptor

struct	LoopControl

struct	Variable

Öffentliche Methoden
string	ToLiteral (string input)

	Parser (Script script, List< Token > tokenStream)

Executable	Parse ()
	Parse the token stream into an executable.

Private Methoden
bool	More ()
	Check if there are more tokens available.

Token	ReadToken ()
	Get the next available token.

Token	LookAhead ()
	Get the next available token without actually increasing the tokenstream index.

Token	LookAhead (int i)
	Get the token 'n' steps forward without actually increasing the tokenstream index.

void	UndoToken ()
	If you read a token wrong, push it back so the stream stays intact.

bool	AssignmentOperator (TokenType tokenType)

OpCode	AssignmentOpcode (TokenType tokenType)

bool	RelationalOperator (TokenType tokenType)

OpCode	RelationalOpcode (TokenType tokenType)

Type	Literal (TokenType tokenType)
	Get the literal type of a token.

Type	Derivate (Token token, Type first, Type second)
	Get the resulting type of two computed types.

void	AllocateVariable (string identifier)
	Allocate a local variable.

void	AllocateFunctionFrame ()
	Increase the function frame index.

string	AllocateTemporaryVariable ()
	Add a temporary variable to the current function frames local memory.

void	FreeFunctionFrame ()
	Decrease the function frame index.

void	ReadSemicolon ()

void	ReadComma ()

void	ReadLeftParenthesis ()

void	ReadRightParenthesis ()

void	ReadLeftBrace ()

void	ReadRightBrace ()

void	ReadLeftBracket ()

void	ReadRightBracket ()

void	ReadPeriod ()

void	InsertDebugInfo (Token token)

string	ReadIdentifier ()
	Read a new (previously NOT declared) identifier.

string	ExpectIdentifier ()
	Read an expected (previously declared) identifier.

void	VariableDeclaration ()
	Shared or local variable declaration.

Variable	StructDeclaration ()
	In fact a struct by now is just an array with pre defined member names. It is stored at the scripts local memory.

Variable	EnumDeclaration ()
	Enumeration stored in scripts local memory.

void	LocalVariableDeclaration ()

void	Run ()

Variable	RoutineCall ()

Variable	Pointer ()
	Array access.

Variable	Member ()
	Member access.

Variable	PreIncrement ()

Variable	PreDecrement ()

Variable	PostIncrement ()

Variable	PostDecrement ()

Variable	ShiftLeft ()

Variable	ShiftRight ()

Variable	BinaryAnd ()

Variable	BinaryOr ()

Variable	BinaryNotAssign ()

Variable	BinaryNot ()

Variable	Xor ()

Variable	Atom ()
	The smallest unit.

Variable	BraceArray ()
	An array enclosed in braces.

Variable	BracketArray ()
	An array enclosed in brackets.

Variable	Factor ()
	Atom \| Array.

Variable	Term ()
	Factor ( [*\|/\|%] Factor )

Variable	Arithmetic ()
	Multiplication and division before Addition and substraction.

Variable	Relation ()

Variable	Not ()
	Proposition.

Variable	And ()
	Conjunction.

Variable	Or ()
	Disjunction (not exclusive)

Variable	VariableAssignment ()

Variable	ArrayAssignment ()

Variable	MemberAssignment ()

Variable	Assignment ()
	An assignment can be a variable assignment, an array assignment or a member assignment.

bool	IsPointer ()

bool	IsMember ()

Variable	Expression ()
	An expression is an assignment or a disjunction.

void	If ()

void	While ()

void	For ()

void	ForEach ()

void	Break ()

void	Continue ()

void	Switch ()

void	Return ()
	By default null is returned.

void	FunctionDeclaration ()
	Parameter variables are already set to true but not assigned yet. Pop all of them in reverse order onto the stack.

Variable	FunctionCall (bool background)
	Call a forward declared function Push all parameter identifier onto the stack and call the function/routine Only functions can run in background because routines are not translated!

Variable	FunctionCall ()
	Can be a call to a forward declared Function or a Routine. To check what it is we look if it is a registered routine, if not it must be a function.

void	Statement ()
	A statement can be a local variable declaration, a statement list, an expression or a keyword.

void	StatementList ()
	A list of statements. If its not a list (not in braces) just return a single statement.

void	LockedStatementList ()

void	Yield ()

void	Wait ()
	Wait for a locked secion of code to be freed.

void	Notify ()

void	ParseScript ()
	After the first function declaration no more variable, struct or enum declarations are allowed anymore.

void	ResolveForwardFunctionDeclarations ()
	Resolve unresolved, forward declared functions.

Private Attribute
Script	script

bool	debugMode

List< Token >	tokenStream

int	nextToken

Dictionary< string, bool >	variables

Dictionary< string, bool >	localVariables

int	functionFrameIndex

Dictionary< Instruction, FunctionDescriptor >	forwardDeclarations

Stack< LoopControl >	loopControl

Derivation	derivation

Executable	executable

Ausführliche Beschreibung

The parser builds an ScriptStack.Runtime.Executable out of the Token stream returned from the ScriptStack.Compiler.Lexer while checking for correct syntax.

The parser takes the output from the Lexer in the form of a Token stream and matches it against syntax rules to detect any errors. The output is an abstract syntax tree in form of Instruction's which can be executed by the ScriptStack.Runtime.Interpreter. More details are coming soon.

Not all methods are well documented yet but please be patient - i am working on it.

See https://en.wikipedia.org/wiki/Parsing

Beschreibung der Konstruktoren und Destruktoren

◆ Parser()

ScriptStack.Compiler.Parser.Parser	(	Script	script,
		List< Token >	tokenStream )

        {
            this.script = script;
            debugMode = false;
            nextToken = 0;
            variables = new Dictionary<String, bool>();
            localVariables = new Dictionary<String, bool>();
            functionFrameIndex = 0;
            forwardDeclarations = new Dictionary<Instruction, FunctionDescriptor>();
            loopControl = new Stack<LoopControl>();
            this.tokenStream = new List<Token>(tokenStream);
            derivation = new Derivation();
            executable = null;
        }

Benutzt ScriptStack.Compiler.Parser.debugMode, ScriptStack.Compiler.Parser.derivation, ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.forwardDeclarations, ScriptStack.Compiler.Parser.functionFrameIndex, ScriptStack.Compiler.Parser.localVariables, ScriptStack.Compiler.Parser.loopControl, ScriptStack.Compiler.Parser.nextToken, ScriptStack.Compiler.Parser.script, ScriptStack.Compiler.Parser.tokenStream und ScriptStack.Compiler.Parser.variables.

Dokumentation der Elementfunktionen

◆ AllocateFunctionFrame()

void ScriptStack.Compiler.Parser.AllocateFunctionFrame ( )

private

Increase the function frame index.

        {
 
            functionFrameIndex++;
 
        }

Benutzt ScriptStack.Compiler.Parser.functionFrameIndex.

Wird benutzt von ScriptStack.Compiler.Parser.EnumDeclaration(), ScriptStack.Compiler.Parser.Statement() und ScriptStack.Compiler.Parser.StructDeclaration().

◆ AllocateTemporaryVariable()

string ScriptStack.Compiler.Parser.AllocateTemporaryVariable ( )

private

Add a temporary variable to the current function frames local memory.

Rückgabe

Noch zu erledigen: performance?

        {
 
            int index = 0;
 
            while (true)
            {
 
                string identifier = "[" + functionFrameIndex + ":" + index + "]";
 
                if (!localVariables.ContainsKey(identifier) && !variables.ContainsKey(identifier))
                {
 
                    localVariables[identifier] = true;
 
                    return identifier;
 
                }
 
                ++index;
 
            }
 
        }

Benutzt ScriptStack.Compiler.Parser.functionFrameIndex, ScriptStack.Compiler.Parser.localVariables und ScriptStack.Compiler.Parser.variables.

◆ AllocateVariable()

void ScriptStack.Compiler.Parser.AllocateVariable ( string identifier )

private

Allocate a local variable.

Parameter

identifier

        {
 
            if (variables.ContainsKey(identifier))
                throw new ParserException("Die Variable '" + identifier + "' ist in einem umschliessenden Bereich bereits deklariert.");
 
            if (localVariables.ContainsKey(identifier))
                throw new ParserException("Die Variable '" + identifier + "' ist in diesem Bereich bereits deklariert.");
 
            localVariables[identifier] = true;
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.DB, Operand.Variable(identifier)));
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.localVariables, ScriptStack.Runtime.Operand.Variable() und ScriptStack.Compiler.Parser.variables.

Wird benutzt von ScriptStack.Compiler.Parser.FunctionDeclaration() und ScriptStack.Compiler.Parser.LocalVariableDeclaration().

◆ And()

Variable ScriptStack.Compiler.Parser.And ( )

private

Conjunction.

Check for proposition (a signed atom)

Rückgabe

        {
 
            List<Instruction> instructions = executable.InstructionsInternal;
 
            Variable first = Not();
            
            while (true)
            {
 
                Token token = ReadToken();
 
                if (token.Type == TokenType.And)
                {
 
                    Variable second = Not();
 
                    instructions.Add(new Instruction(OpCode.AND, Operand.Variable(first.name), Operand.Variable(second.name)));
 
                    first.derivatedType = Derivate(token, first.derivatedType, second.derivatedType);
 
                    break;
 
                }
 
                else
                {
 
                    UndoToken();
 
                    return first;
 
                }
 
            }
 
            return first;
 
        }

Benutzt ScriptStack.Compiler.Parser.Derivate(), ScriptStack.Compiler.Parser.Variable.derivatedType, ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.Not(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Compiler.Parser.UndoToken() und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Or().

◆ Arithmetic()

Variable ScriptStack.Compiler.Parser.Arithmetic ( )

private

Multiplication and division before Addition and substraction.

Refer to https://en.wikipedia.org/wiki/Order_of_operations

Rückgabe

        {
 
            List<Instruction> listInstructions = executable.InstructionsInternal;
 
            Variable first = Term();
 
            Variable second = new Variable();
 
            while(true)
            {
 
                Token token = ReadToken();
 
                switch (token.Type)
                {
 
                    case TokenType.Plus:
 
                        second = Term();
 
                        listInstructions.Add(new Instruction(OpCode.ADD, Operand.Variable(first.name), Operand.Variable(second.name)));
 
                        first.derivatedType = Derivate(token, first.derivatedType, second.derivatedType);
 
                        break;
 
                    case TokenType.Minus:
 
                        second = Term();
 
                        listInstructions.Add(new Instruction(OpCode.SUB, Operand.Variable(first.name), Operand.Variable(second.name)));
 
                        break;
 
                    default:
 
                        UndoToken();
 
                        return first;
 
                }
 
            }
 
        }

Benutzt ScriptStack.Compiler.Parser.Derivate(), ScriptStack.Compiler.Parser.Variable.derivatedType, ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Parser.Term(), ScriptStack.Compiler.Token.Type, ScriptStack.Compiler.Parser.UndoToken(), ScriptStack.Runtime.Variable und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Relation().

◆ ArrayAssignment()

Variable ScriptStack.Compiler.Parser.ArrayAssignment ( )

private

Rückgabe

        {
 
            string identifier = ExpectIdentifier();
 
            List<Instruction> listInstructions = executable.InstructionsInternal;
 
            Variable tmp = new Variable();
 
            string src = identifier;
 
            string dst = null;
 
            while (!AssignmentOperator(LookAhead().Type))
            {
 
                ReadLeftBracket();
 
                tmp = Expression();
 
                ReadRightBracket();
 
                if (!AssignmentOperator(LookAhead().Type))
                {
 
                    dst = AllocateTemporaryVariable();
 
                    listInstructions.Add(new Instruction(OpCode.MOV, Operand.Variable(dst), Operand.CreatePointer(src, tmp.name)));
 
                    src = dst;
 
                }
 
            }
 
            Token tok = ReadToken();
 
            Variable expression = Expression();
 
            if (dst == null)
                dst = identifier;
 
            listInstructions.Add(new Instruction(AssignmentOpcode(tok.Type), Operand.CreatePointer(dst, tmp.name), Operand.Variable(expression.name)));
 
            string tmpIdentifier = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(tmpIdentifier), Operand.CreatePointer(dst, tmp.name)));
 
            return new Variable(tmpIdentifier, Scope.Local, expression.derivatedType);
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Assignment().

◆ Assignment()

Variable ScriptStack.Compiler.Parser.Assignment ( )

private

An assignment can be a variable assignment, an array assignment or a member assignment.

Rückgabe

        {
 
            string identifier = ExpectIdentifier();
 
            Token token = LookAhead();
 
            switch (token.Type)
            {
 
                case TokenType.Assign:
                case TokenType.AssignPlus:
                case TokenType.AssignMinus:
                case TokenType.AssignMultiply:
                case TokenType.AssignDivide:
                case TokenType.AssignBinaryAnd:
                case TokenType.AssignBinaryOr:
                case TokenType.AssignXor:
                case TokenType.AssignBinaryNot:
                case TokenType.AssignModulo:
                    UndoToken();
                    return VariableAssignment();
 
                case TokenType.LeftBracket:
                    UndoToken();
                    return ArrayAssignment();
 
                case TokenType.Period:
                    UndoToken();
                    return MemberAssignment();
 
                default:
                    throw new ExecutionException("Es wurde ein Zuweisungoperator erwartet.");
 
            }
 
        }

Benutzt ScriptStack.Compiler.Parser.ArrayAssignment(), ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.MemberAssignment(), ScriptStack.Compiler.Token.Type, ScriptStack.Compiler.Parser.UndoToken() und ScriptStack.Compiler.Parser.VariableAssignment().

Wird benutzt von ScriptStack.Compiler.Parser.Expression(), ScriptStack.Compiler.Parser.For() und ScriptStack.Compiler.Parser.LocalVariableDeclaration().

◆ AssignmentOpcode()

OpCode ScriptStack.Compiler.Parser.AssignmentOpcode ( TokenType tokenType )

private

Parameter

tokenType

Rückgabe

        {
 
            switch (tokenType)
            {
 
                case TokenType.Assign: return OpCode.MOV;
                case TokenType.AssignPlus: return OpCode.ADD;
                case TokenType.AssignMinus: return OpCode.SUB;
                case TokenType.AssignMultiply: return OpCode.MUL;
                case TokenType.AssignDivide: return OpCode.DIV;
                case TokenType.AssignBinaryAnd: return OpCode.ANDB;
                case TokenType.AssignBinaryOr: return OpCode.ORB;
                case TokenType.AssignXor: return OpCode.XOR;
                case TokenType.AssignBinaryNot: return OpCode.NOTB;
                case TokenType.AssignModulo: return OpCode.MOD;
                default:
                    throw new ParserException("Der Token '" + tokenType + "' ist kein Zuweisungsoperator.");
 
            }
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.ArrayAssignment(), ScriptStack.Compiler.Parser.MemberAssignment() und ScriptStack.Compiler.Parser.VariableAssignment().

◆ AssignmentOperator()

bool ScriptStack.Compiler.Parser.AssignmentOperator ( TokenType tokenType )

private

Parameter

tokenType

Rückgabe

        {
 
            switch (tokenType)
            {
 
                case TokenType.Assign:
                case TokenType.AssignPlus:
                case TokenType.AssignMinus:
                case TokenType.AssignMultiply:
                case TokenType.AssignDivide:
                case TokenType.AssignBinaryAnd:
                case TokenType.AssignBinaryOr:
                case TokenType.AssignXor:
                case TokenType.AssignBinaryNot:
                case TokenType.AssignModulo:
                    return true;
 
                default:
                    return false;
 
            }
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.ArrayAssignment(), ScriptStack.Compiler.Parser.IsMember(), ScriptStack.Compiler.Parser.IsPointer(), ScriptStack.Compiler.Parser.MemberAssignment() und ScriptStack.Compiler.Parser.VariableAssignment().

◆ Atom()

Variable ScriptStack.Compiler.Parser.Atom ( )

private

The smallest unit.

Rückgabe

        {
 
            Token token = ReadToken();
 
            Variable variable = new Variable();
 
            switch (token.Type)
            {
 
                case TokenType.Minus:
 
                    variable = Atom();
 
                    string tmpIdentifier = AllocateTemporaryVariable();
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(tmpIdentifier), Operand.Variable(variable.name)));
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.NEG, Operand.Variable(tmpIdentifier)));
 
                    variable.name = tmpIdentifier;
 
                    return variable;
 
                case TokenType.Null:
 
                    variable.name = AllocateTemporaryVariable();
 
                    variable.scope = Scope.Local;
 
                    variable.derivatedType = typeof(NullReference);
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(variable.name), Operand.Literal(NullReference.Instance)));
 
                    return variable;
 
                case TokenType.Integer:
                case TokenType.Float:
                case TokenType.Boolean:
                case TokenType.String:
                case TokenType.Char:
 
                    variable.name = AllocateTemporaryVariable();
 
                    variable.scope = Scope.Local;
 
                    variable.derivatedType = Literal(token.Type);
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(variable.name), Operand.Literal(token.Lexeme)));
 
                    return variable;
 
                case TokenType.Increment:
 
                    UndoToken();
 
                    variable = PreIncrement();
 
                    return variable;
 
                case TokenType.Decrement:
 
                    UndoToken();
 
                    variable = PreDecrement();
 
                    return variable;
 
                case TokenType.Identifier:
 
                    string identifier = token.Lexeme.ToString();
 
                    switch (LookAhead().Type)
                    {
 
                        case TokenType.Increment:
 
                            UndoToken();
 
                            return PostIncrement();
 
                        case TokenType.Decrement:
 
                            UndoToken();
 
                            return PostDecrement();
 
                        case TokenType.LeftBracket:
 
                            UndoToken();
 
                            return Pointer();
 
                        case TokenType.Period:
 
                            UndoToken();
 
                            return Member();
 
                        case TokenType.LeftParen:
 
                            UndoToken();
 
                            return FunctionCall();
 
                        case TokenType.ShiftLeft:
 
                            UndoToken();
 
                            return ShiftLeft();
 
                        case TokenType.ShiftRight:
 
                            UndoToken();
 
                            return ShiftRight();
 
                        default:
 
                            UndoToken();
 
                            identifier = ExpectIdentifier();
 
                            variable.name = AllocateTemporaryVariable();
 
                            variable.scope = Scope.Local;
 
                            variable.derivatedType = null;
 
                            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(variable.name), Operand.Variable(identifier)));
 
                            return variable;
 
                    }
 
                case TokenType.LeftParen:
 
                    variable = Expression();
 
                    ReadRightParenthesis();
 
                    return variable;
 
                default:
 
                    throw new ParserException( "Fehlerhafter Token '" + token + "'.", token);
 
            }
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Atom() und ScriptStack.Compiler.Parser.Factor().

◆ BinaryAnd()

Variable ScriptStack.Compiler.Parser.BinaryAnd ( )

private

Rückgabe

        {
 
            string left = ExpectIdentifier();
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.AssignBinaryAnd)
                throw new ParserException("Binary AND '&=' erwartet.", token);
 
            Variable right = Factor();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.ANDB, Operand.Variable(left), Operand.Variable(right.name)));
 
            return right;
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.Factor(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

◆ BinaryNot()

Variable ScriptStack.Compiler.Parser.BinaryNot ( )

private

Rückgabe

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.AssignBinaryNot)
                throw new ParserException("Binary NOT '~=' erwartet.", token);
 
            Variable right = Factor();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.NOTB, Operand.Variable(right.name)));
 
            return right;
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Factor(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

◆ BinaryNotAssign()

Variable ScriptStack.Compiler.Parser.BinaryNotAssign ( )

private

Rückgabe

        {
 
            string left = ExpectIdentifier();
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.AssignBinaryNot)
                throw new ParserException("Binary NEG '~=' erwartet.", token);
 
            Variable right = Factor();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.NOTB, Operand.Variable(left), Operand.Variable(right.name)));
 
            return right;
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.Factor(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

◆ BinaryOr()

Variable ScriptStack.Compiler.Parser.BinaryOr ( )

private

Rückgabe

        {
 
            string left = ExpectIdentifier();
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.AssignBinaryOr)
                throw new ParserException("Binary OR '|=' erwartet.", token);
 
            Variable right = Factor();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.ORB, Operand.Variable(left), Operand.Variable(right.name)));
 
            return right;
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.Factor(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

◆ BraceArray()

Variable ScriptStack.Compiler.Parser.BraceArray ( )

private

An array enclosed in braces.

Rückgabe

        {
 
            ReadLeftBrace();
 
            int index = 0;
 
            string identifier = AllocateTemporaryVariable();
 
            string indexIdentifier = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.DC, Operand.Variable(identifier)));
 
            if (LookAhead().Type != TokenType.RightBrace)
            {
 
                while (true)
                {
 
                    Variable tmp = Expression();
 
                    Token token = LookAhead();
 
                    if (token.Type == TokenType.Comma || token.Type == TokenType.SemiColon || token.Type == TokenType.RightBrace)
                    {
 
                        executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.MemberVariable(identifier, index++), Operand.Variable(tmp.name)));
 
                        if (token.Type == TokenType.RightBrace)
                            break;
 
                        /* todo: could be comma or semicolon, depends on current cultureinfo */
                        if (token.Type == TokenType.Comma)
                            ReadComma();
 
                        if (token.Type == TokenType.SemiColon)
                            ReadSemicolon();
 
                    }
 
                    else if (token.Type == TokenType.Colon)
                    {
 
                        ReadToken();
 
                        Variable variableKey = tmp;
 
                        tmp = Expression();
 
                        executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.CreatePointer(identifier, variableKey.name), Operand.Variable(tmp.name)));
 
                        if (LookAhead().Type == TokenType.RightBrace)
                            break;
 
                        /* todo: could be comma or semicolon, depends on current cultureinfo */
                        if (LookAhead().Type == TokenType.Comma)
                            ReadComma();
 
                        if (LookAhead().Type == TokenType.SemiColon)
                            ReadSemicolon();
 
                    }
 
                    else
                        throw new ParserException( "Ein Comma ',', Semicolon ';' oder Colon ':' wurde erwartet.");
 
                }
 
            }
 
            ReadRightBrace();
 
            return new Variable(identifier, Scope.Local, typeof(ArrayList));
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Factor().

◆ BracketArray()

Variable ScriptStack.Compiler.Parser.BracketArray ( )

private

An array enclosed in brackets.

Rückgabe

        {
 
            ReadLeftBracket();
 
            int index = 0;
 
            string identifier = AllocateTemporaryVariable();
 
            string indexIdentifier = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.DC, Operand.Variable(identifier)));
 
            if (LookAhead().Type != TokenType.RightBracket)
            {
 
                while (true)
                {
 
                    Variable tmp = Expression();
 
                    Token token = LookAhead();
 
                    if (token.Type == TokenType.Comma || token.Type == TokenType.RightBracket)
                    {
 
                        executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.MemberVariable(identifier, index++), Operand.Variable(tmp.name)));
 
                        if (token.Type == TokenType.RightBracket)
                            break;
 
                        ReadComma();
 
                    }
 
                    else if (token.Type == TokenType.Colon)
                    {
 
                        ReadToken();
 
                        Variable key = tmp;
 
                        tmp = Expression();
 
                        executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.CreatePointer(identifier, key.name), Operand.Variable(tmp.name)));
 
                        if(LookAhead().Type == TokenType.RightBracket)
                            break;
 
                        ReadComma();
 
                    }
 
                    else
                        throw new ParserException( "Ein Comma ',' oder Colon ':' wurde erwartet.");
 
                }
 
            }
 
            ReadRightBracket();
 
            return new Variable(identifier, Scope.Local, typeof(ArrayList));
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Factor().

◆ Break()

void ScriptStack.Compiler.Parser.Break ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Break)
                throw new ParserException("Keyword 'break' erwartet.", token);
 
            ReadSemicolon();
 
            if (loopControl.Count == 0)
                throw new ParserException("Das Keyword 'break' kann nur innerhalb von Loops verwendet werden.", token);
 
            Instruction breakInstruction = loopControl.Peek().Break;
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.JMP, Operand.AllocateInstructionPointer(breakInstruction)));
 
        }

Benutzt ScriptStack.Runtime.Operand.AllocateInstructionPointer(), ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.loopControl, ScriptStack.Compiler.Parser.ReadSemicolon(), ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ Continue()

void ScriptStack.Compiler.Parser.Continue ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Continue)
                throw new ParserException("Keyword 'continue' erwartet.", token);
 
            ReadSemicolon();
 
            if (loopControl.Count == 0)
                throw new ParserException("Das Keyword 'continue' kann nur innerhalb von Loops verwendet werden.", token);
 
            Instruction continueInstruction = loopControl.Peek().Continue;
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.JMP, Operand.AllocateInstructionPointer(continueInstruction)));
 
        }

Benutzt ScriptStack.Runtime.Operand.AllocateInstructionPointer(), ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.loopControl, ScriptStack.Compiler.Parser.ReadSemicolon(), ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ Derivate()

Type ScriptStack.Compiler.Parser.Derivate	(	Token	token,
		Type	first,
		Type	second )

private

Get the resulting type of two computed types.

Parameter

token
first
second

Rückgabe

        {
 
            return derivation.Derivate(token, first, second);
 
        }

Benutzt ScriptStack.Compiler.Parser.derivation.

Wird benutzt von ScriptStack.Compiler.Parser.And(), ScriptStack.Compiler.Parser.Arithmetic(), ScriptStack.Compiler.Parser.Or(), ScriptStack.Compiler.Parser.Relation() und ScriptStack.Compiler.Parser.Term().

◆ EnumDeclaration()

Variable ScriptStack.Compiler.Parser.EnumDeclaration ( )

private

Enumeration stored in scripts local memory.

Noch zu erledigen: Enum is in beta

Rückgabe

        {
 
            AllocateFunctionFrame();
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Enum)
                throw new ParserException("Enumerationen werden mit 'enum' deklariert.", token);
 
            InsertDebugInfo(token);
 
            string identifier = ReadIdentifier();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.DCO, Operand.Variable(identifier)));
 
            string alloc = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(alloc), Operand.Variable(identifier)));
 
            variables[identifier] = true;
 
            ArrayList array = new ArrayList();
 
            ReadLeftBrace();
 
            int i = 0;
 
            while (true)
            {
 
                Token tok = ReadToken();
 
                if (tok.Type == TokenType.RightBrace)
                {
 
                    UndoToken();
                    break;
 
                }
 
                if (LookAhead().Type == TokenType.RightBrace)
                {
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.ADD, Operand.CreatePointer(identifier, (string)tok.Lexeme), Operand.Literal(i)));
                    array.Add(tok.Lexeme, i);
                    break;
 
                }
                else
                {
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.ADD, Operand.CreatePointer(identifier, (string)tok.Lexeme), Operand.Literal(i)));
 
                    array.Add(tok.Lexeme, i);
 
                }
 
                if (LookAhead().Type == TokenType.RightBrace)
                    break;
 
                ReadComma();
 
                i++;
 
            }
 
            ReadRightBrace();
 
            executable.ScriptMemory[identifier] = array;
 
            FreeFunctionFrame();
 
            return new Variable(identifier, Scope.Local, typeof(ArrayList));
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.ParseScript().

◆ ExpectIdentifier()

string ScriptStack.Compiler.Parser.ExpectIdentifier ( )

private

Read an expected (previously declared) identifier.

Rückgabe

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Identifier)
                throw new ParserException("Ein Keyword oder eine Variable wurde erwartet.", token);
 
            string identifier = token.Lexeme.ToString();
 
            if (!variables.ContainsKey(identifier) && !localVariables.ContainsKey(identifier))
                throw new ParserException("Ein nicht vorhandener Identifier '" + identifier + "' wurde referenziert.", token);
 
            return identifier;
 
        }

Benutzt ScriptStack.Compiler.Token.Lexeme, ScriptStack.Compiler.Parser.localVariables, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Compiler.Parser.variables.

◆ Expression()

Variable ScriptStack.Compiler.Parser.Expression ( )

private

An expression is an assignment or a disjunction.

Rückgabe

        {
 
            if (IsPointer() || IsMember())
                return Assignment();
 
            else
                return Or();
 
        }

Benutzt ScriptStack.Compiler.Parser.Assignment(), ScriptStack.Compiler.Parser.IsMember(), ScriptStack.Compiler.Parser.IsPointer() und ScriptStack.Compiler.Parser.Or().

◆ Factor()

Variable ScriptStack.Compiler.Parser.Factor ( )

private

Atom | Array.

Rückgabe

        {
 
            if (LookAhead().Type == TokenType.LeftBrace)
                return BraceArray();
 
            // test
            if (LookAhead().Type == TokenType.LeftBracket)
                return BracketArray();
 
            Variable variable = Atom();
 
            return variable;
 
        }

Benutzt ScriptStack.Compiler.Parser.Atom(), ScriptStack.Compiler.Parser.BraceArray(), ScriptStack.Compiler.Parser.BracketArray() und ScriptStack.Compiler.Parser.LookAhead().

Wird benutzt von ScriptStack.Compiler.Parser.BinaryAnd(), ScriptStack.Compiler.Parser.BinaryNot(), ScriptStack.Compiler.Parser.BinaryNotAssign(), ScriptStack.Compiler.Parser.BinaryOr(), ScriptStack.Compiler.Parser.ShiftLeft(), ScriptStack.Compiler.Parser.ShiftRight(), ScriptStack.Compiler.Parser.Term() und ScriptStack.Compiler.Parser.Xor().

◆ For()

void ScriptStack.Compiler.Parser.For ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.For)
                throw new ParserException("Keyword 'for' erwartet.", token);
 
            ReadLeftParenthesis();
 
            if (LookAhead().Type == TokenType.SemiColon)
                ReadSemicolon();
 
            else if (LookAhead().Type == TokenType.Var)
                LocalVariableDeclaration();
 
            else
            {
 
                Assignment();
 
                ReadSemicolon();
 
            }
 
            Instruction start = new Instruction(OpCode.NOP);
 
            executable.InstructionsInternal.Add(start);
 
            Instruction continueInstruction = new Instruction(OpCode.NOP);
 
            Variable condition = new Variable();
 
            if (LookAhead().Type == TokenType.SemiColon)
            {
 
                condition = new Variable(AllocateTemporaryVariable(), Scope.Local, typeof(bool));
 
                executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(condition.name), Operand.Literal(true)));
 
                ReadSemicolon();
 
            }
 
            else
            {
 
                condition = Expression();
 
                if (condition.derivatedType != null && condition.derivatedType != typeof(bool))
                    throw new ParserException("In For Loops wird ein logischer Ausdruck oder 'null' erwartet.", token);
 
                ReadSemicolon();
 
            }
 
            List<Instruction> expression = null;
 
            if (LookAhead().Type != TokenType.RightParen)
            {
 
                int loopStart = executable.InstructionsInternal.Count;
 
                Expression();
 
                int loopCount = executable.InstructionsInternal.Count - loopStart; 
 
                expression = executable.InstructionsInternal.GetRange(loopStart, loopCount);
 
                executable.InstructionsInternal.RemoveRange(loopStart, loopCount);
 
            }
 
            else
                expression = new List<Instruction>();
 
            ReadRightParenthesis();
 
            Instruction end = new Instruction(OpCode.NOP);
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.JNZ, Operand.Variable(condition.name), Operand.AllocateInstructionPointer(end)));
 
            LoopControl loopControl = new LoopControl();
 
            loopControl.Break = end;
 
            loopControl.Continue = continueInstruction;
 
            this.loopControl.Push(loopControl);
 
            StatementList();
 
            this.loopControl.Pop();
 
            executable.InstructionsInternal.Add(continueInstruction);
 
            executable.InstructionsInternal.AddRange(expression);
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.JMP, Operand.AllocateInstructionPointer(start)));
 
            executable.InstructionsInternal.Add(end);
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ ForEach()

void ScriptStack.Compiler.Parser.ForEach ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Foreach)
                throw new ParserException("Keyword 'foreach' erwartet.", token);
 
            ReadLeftParenthesis();
 
            string key = null;
 
            string val = ExpectIdentifier();
 
            token = ReadToken();
 
            if (token.Type == TokenType.Comma)
            {
 
                key = val;
 
                val = ExpectIdentifier();
 
                token = ReadToken();
 
            }
 
            if (token.Type != TokenType.In)
                throw new ParserException("Keyword 'in' erwartet.", token);
 
            if (key == null)
                key = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(key), Operand.Literal(NullReference.Instance)));
 
            Instruction start = new Instruction(OpCode.NOP);
 
            executable.InstructionsInternal.Add(start);
 
            Variable array = Expression();
 
            if (array.derivatedType != null && array.derivatedType != typeof(ArrayList))
                throw new ParserException("In ForEach Loops wird ein logischer Ausdruck erwartet.", token);
 
            ReadRightParenthesis();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.PTR, Operand.Variable(key), Operand.Variable(array.name)));
 
            string identifier = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(identifier), Operand.Variable(key)));
 
            //executable.InstructionsInternal.Add(new Instruction(OpCode.CEQ, Operand.Variable(identifier), Operand.Literal(true)));
            executable.InstructionsInternal.Add(new Instruction(OpCode.TEST, Operand.Variable(identifier)));
 
            Instruction end = new Instruction(OpCode.NOP);
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.JZ, Operand.Variable(identifier), Operand.AllocateInstructionPointer(end)));
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(val), Operand.CreatePointer(array.name, key)));
 
            LoopControl loopControl = new LoopControl();
 
            loopControl.Break = end;
 
            loopControl.Continue = start;
 
            this.loopControl.Push(loopControl);
 
            StatementList();
 
            this.loopControl.Pop();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.JMP, Operand.AllocateInstructionPointer(start)));
 
            executable.InstructionsInternal.Add(end);
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ FreeFunctionFrame()

void ScriptStack.Compiler.Parser.FreeFunctionFrame ( )

private

Decrease the function frame index.

        {
 
            if (functionFrameIndex == 0)
                return;
 
            List<string> candidates = new List<string>();
 
            foreach (string identifier in localVariables.Keys)
                if (identifier.StartsWith("[" + functionFrameIndex + ":"))
                    candidates.Add(identifier);
 
            foreach (string identifier in candidates)
                localVariables.Remove(identifier);
 
            --functionFrameIndex;
 
        }

Benutzt ScriptStack.Compiler.Parser.functionFrameIndex und ScriptStack.Compiler.Parser.localVariables.

Wird benutzt von ScriptStack.Compiler.Parser.EnumDeclaration(), ScriptStack.Compiler.Parser.Statement() und ScriptStack.Compiler.Parser.StructDeclaration().

◆ FunctionCall() [1/2]

Variable ScriptStack.Compiler.Parser.FunctionCall ( )

private

Can be a call to a forward declared Function or a Routine. To check what it is we look if it is a registered routine, if not it must be a function.

Rückgabe

        {
 
            string functionName = ReadIdentifier();
 
            UndoToken();
 
            if (executable.Script.Manager.IsRegistered(functionName))
                return RoutineCall();
 
            else
                return FunctionCall(false);
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.FunctionCall(), ScriptStack.Manager.IsRegistered(), ScriptStack.Runtime.Script.Manager, ScriptStack.Compiler.Parser.ReadIdentifier(), ScriptStack.Compiler.Parser.RoutineCall(), ScriptStack.Runtime.Executable.Script und ScriptStack.Compiler.Parser.UndoToken().

Wird benutzt von ScriptStack.Compiler.Parser.Atom(), ScriptStack.Compiler.Parser.FunctionCall() und ScriptStack.Compiler.Parser.Run().

◆ FunctionCall() [2/2]

Variable ScriptStack.Compiler.Parser.FunctionCall ( bool background )

private

Call a forward declared function Push all parameter identifier onto the stack and call the function/routine Only functions can run in background because routines are not translated!

Noch zu erledigen: translate routines to msil?

Parameter

background

Rückgabe

        {
 
            string name = ReadIdentifier();
 
            // lets expect it is a function
            bool forwardDeclared = true;
 
            // if it is registered to the manager it is a routine of course
            if (!executable.Functions.ContainsKey(name))
                forwardDeclared = false;
 
            ReadLeftParenthesis();
 
            uint parameterCount = 0;
 
            if (LookAhead().Type != TokenType.RightParen)
            {
 
                // parameters are on the stack, already set to true so we just assign them
                while (true)
                {
 
                    Variable parameter = Expression();
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.PUSH, Operand.Variable(parameter.name)));
 
                    ++parameterCount;
 
                    if (LookAhead().Type == TokenType.RightParen)
                        break;
 
                    else
                        ReadComma();
 
                }
 
            }
 
            ReadRightParenthesis();
 
            Instruction instruction = null;
 
            Function function = null;
 
            if (forwardDeclared)
            {
 
                function = executable.Functions[name];
 
                if (function.ParameterCount > parameterCount)
                    throw new ParserException("Der Aufruf der Funktion '" + name + "' hat fehlende Parameter. Erwartet werden " + function.ParameterCount + " Parameter.");
 
                // \todo should we just throw the rest?
                if (function.ParameterCount < parameterCount)
                    throw new ParserException("Der Aufruf der Funktion '" + name + "' hat zu viele Parameter. Erwartet werden " + function.ParameterCount + " Parameter.");
 
            }
 
            Variable variable = new Variable();
 
            if (background)
            {
 
                instruction = new Instruction(OpCode.RUN, Operand.AllocateFunctionPointer(function));
 
                executable.InstructionsInternal.Add(instruction);
 
            }
 
            else
            {
 
                instruction = new Instruction(OpCode.CALL, Operand.AllocateFunctionPointer(function));
 
                executable.InstructionsInternal.Add(instruction);
 
                // the result is popped onto the stack so a temp variable is created like '[0:0]'
                variable.name = AllocateTemporaryVariable();
 
                variable.scope = Scope.Local;
 
                variable.derivatedType = null;
 
                executable.InstructionsInternal.Add(new Instruction(OpCode.POP, Operand.Variable(variable.name)));
 
            }
 
            if (!forwardDeclared)
            {
 
                FunctionDescriptor functionDescriptor = new FunctionDescriptor();
 
                functionDescriptor.name = name;
 
                functionDescriptor.parameterCount = parameterCount;
 
                functionDescriptor.instruction = null;
 
                forwardDeclarations[instruction] = functionDescriptor;
 
            }
 
            return variable;
 
        }

◆ FunctionDeclaration()

void ScriptStack.Compiler.Parser.FunctionDeclaration ( )

private

Parameter variables are already set to true but not assigned yet. Pop all of them in reverse order onto the stack.

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Function)
                throw new ParserException("Funktion werden mit 'function' deklariert.", token);
 
            string functionName = ReadIdentifier();
 
            if (executable.Functions.ContainsKey(functionName))
                throw new ParserException("Die Funktion '" + functionName + "' ist bereits vorhanden.", token);
 
            ReadLeftParenthesis();
 
            InsertDebugInfo(token);
 
            List<string> parameters = new List<string>();
 
            if (LookAhead().Type != TokenType.RightParen)
            {
 
                while (true)
                {
 
                    token = ReadToken();
 
                    if (token.Type != TokenType.Identifier)
                        throw new ParserException("Unerwarteter Token '" + token.Lexeme + "'.", token);
 
                    string parameter = token.Lexeme.ToString();
 
                    AllocateVariable(parameter);
 
                    parameters.Add(parameter);
 
                    token = LookAhead();
 
                    if (token.Type == TokenType.Comma)
                        ReadComma();
 
                    else if (token.Type == TokenType.RightParen)
                        break;
 
                    else
                        throw new ParserException("Comma ',' oder schliessende Klammer ')' erwartet.");
 
                }
 
            }
 
            ReadRightParenthesis();
 
            Instruction scriptInstructionFunctionEntry = new Instruction(OpCode.NOP);
 
            executable.InstructionsInternal.Add(scriptInstructionFunctionEntry);
 
            Function scriptFunction = new Function(executable, functionName, parameters, scriptInstructionFunctionEntry);
 
            executable.Functions[functionName] = scriptFunction;
 
            parameters.Reverse();
 
            foreach (string parameter in parameters)
            {
 
                Instruction scriptInstructionPop = new Instruction(OpCode.POP, Operand.Variable(parameter));
 
                executable.InstructionsInternal.Add(scriptInstructionPop);
 
            }
 
            StatementList();
 
            executable.InstructionsInternal.Add(new Instruction( OpCode.PUSH, Operand.Literal(NullReference.Instance)));
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.RET));
 
            localVariables.Clear();
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.ParseScript().

◆ If()

void ScriptStack.Compiler.Parser.If ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.If)
                throw new ParserException( "Keyword 'if' erwartet.", token);
 
            ReadLeftParenthesis();
 
            Variable condition = Expression();
 
            ReadRightParenthesis();
 
            Instruction start = new Instruction(OpCode.NOP);
 
            Instruction end = new Instruction(OpCode.NOP);
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.JNZ, Operand.Variable(condition.name), Operand.AllocateInstructionPointer(start)));
 
            StatementList();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.JMP, Operand.AllocateInstructionPointer(end)));
 
            executable.InstructionsInternal.Add(start);
 
            if (LookAhead().Type == TokenType.Else)
            {
 
                ReadToken();
 
                StatementList();
            }
 
            executable.InstructionsInternal.Add(end);
 
        }

Benutzt ScriptStack.Runtime.Operand.AllocateInstructionPointer(), ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Expression(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadLeftParenthesis(), ScriptStack.Compiler.Parser.ReadRightParenthesis(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Parser.StatementList(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ InsertDebugInfo()

void ScriptStack.Compiler.Parser.InsertDebugInfo ( Token token )

private

        {
 
            if (!debugMode)
                return;
 
            string text = token.Text;
 
            //text = text.Replace("\r", "").Replace("\n", "");
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.DBG, Operand.Literal(token.Line), Operand.Literal(text)));
 
        }

Benutzt ScriptStack.Compiler.Parser.debugMode, ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Token.Line, ScriptStack.Runtime.Operand.Literal() und ScriptStack.Compiler.Token.Text.

Wird benutzt von ScriptStack.Compiler.Parser.EnumDeclaration(), ScriptStack.Compiler.Parser.FunctionDeclaration(), ScriptStack.Compiler.Parser.Statement(), ScriptStack.Compiler.Parser.StructDeclaration(), ScriptStack.Compiler.Parser.Switch() und ScriptStack.Compiler.Parser.VariableDeclaration().

◆ IsMember()

bool ScriptStack.Compiler.Parser.IsMember ( )

private

Rückgabe

        {
 
            Token start = LookAhead();
 
            if (start.Type != TokenType.Identifier)
                return false;
 
            string identifier = ReadIdentifier();
 
            while (LookAhead().Type == TokenType.Period)
            {
 
                ReadPeriod();
 
                Token token = ReadToken();
 
                if (token.Type != TokenType.Identifier)
                {
 
                    while (LookAhead() != start)
                        UndoToken();
 
                    return false;
 
                }
 
            }
 
            Token tok = ReadToken();
 
            while (LookAhead() != start)
                UndoToken();
 
            return AssignmentOperator(tok.Type);
 
        }

Benutzt ScriptStack.Compiler.Parser.AssignmentOperator(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.ReadIdentifier(), ScriptStack.Compiler.Parser.ReadPeriod(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Compiler.Parser.UndoToken().

Wird benutzt von ScriptStack.Compiler.Parser.Expression().

◆ IsPointer()

bool ScriptStack.Compiler.Parser.IsPointer ( )

private

Rückgabe

        {
 
            Token start = LookAhead();
 
            if (start.Type != TokenType.Identifier)
                return false;
 
            int iInstructionCheckpoint = executable.InstructionsInternal.Count;
 
            string identifier = ReadIdentifier();
 
            while (LookAhead().Type == TokenType.LeftBracket)
            {
 
                ReadLeftBracket();
                Expression();
                ReadRightBracket();
 
            }
 
            Token tok = ReadToken();
 
            while (LookAhead() != start)
                UndoToken();
 
            executable.InstructionsInternal.RemoveRange(iInstructionCheckpoint, executable.InstructionsInternal.Count - iInstructionCheckpoint);
 
            return AssignmentOperator(tok.Type);
 
        }

Benutzt ScriptStack.Compiler.Parser.AssignmentOperator(), ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Expression(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.ReadIdentifier(), ScriptStack.Compiler.Parser.ReadLeftBracket(), ScriptStack.Compiler.Parser.ReadRightBracket(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Compiler.Parser.UndoToken().

Wird benutzt von ScriptStack.Compiler.Parser.Expression().

◆ Literal()

Type ScriptStack.Compiler.Parser.Literal ( TokenType tokenType )

private

Get the literal type of a token.

Parameter

tokenType

Rückgabe

Noch zu erledigen: float <> double

        {
 
            switch (tokenType)
            {
 
                case TokenType.Integer:
                    return typeof(int);
                case TokenType.Float:
                    return typeof(float);
                case TokenType.Boolean:
                    return typeof(bool);
                case TokenType.String:
                    return typeof(string);
                case TokenType.Char:
                    return typeof(char);
                default:
                    throw new ParserException( "Der Token '" + tokenType.ToString() + "' kann keinem Literal zugeordnet werden.");
 
            }
 
        }

◆ LocalVariableDeclaration()

void ScriptStack.Compiler.Parser.LocalVariableDeclaration ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Var)
                throw new ParserException( "Lokale Variablen werden mit 'var' deklariert.", token);
 
            string identifier = ReadIdentifier();
 
            while (true)
            {
 
                AllocateVariable(identifier);
 
                token = ReadToken();
 
                if (token.Type == TokenType.SemiColon)
                    return;
 
                if (token.Type == TokenType.Assign)
                {
 
                    UndoToken();
 
                    UndoToken();
 
                    Assignment();
 
                    token = ReadToken();
 
                    if (token.Type == TokenType.SemiColon)
                        return;
 
                }
 
                if (token.Type != TokenType.Comma)
                    throw new ParserException( "Comma ',' erwartet.", token);
 
                identifier = ReadIdentifier();
 
            }
 
        }

Benutzt ScriptStack.Compiler.Parser.AllocateVariable(), ScriptStack.Compiler.Parser.Assignment(), ScriptStack.Compiler.Parser.ReadIdentifier(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Compiler.Parser.UndoToken().

Wird benutzt von ScriptStack.Compiler.Parser.For() und ScriptStack.Compiler.Parser.Statement().

◆ LockedStatementList()

void ScriptStack.Compiler.Parser.LockedStatementList ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Lock)
                throw new ExecutionException("ParserException: Keyword 'lock' erwartet.");
 
            Variable variable = Expression();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.LOCK, Operand.Variable(variable.name)));
 
            Statement();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.FREE, Operand.Variable(variable.name)));
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Expression(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Parser.Statement(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ LookAhead() [1/2]

Token ScriptStack.Compiler.Parser.LookAhead ( )

private

Get the next available token without actually increasing the tokenstream index.

Rückgabe

        {
 
            if (!More())
                throw new ParserException("Es sind keine weiteren Token vorhanden.");
 
            return tokenStream[nextToken];
 
        }

Benutzt ScriptStack.Compiler.Parser.More(), ScriptStack.Compiler.Parser.nextToken und ScriptStack.Compiler.Parser.tokenStream.

◆ LookAhead() [2/2]

Token ScriptStack.Compiler.Parser.LookAhead ( int i )

private

Get the token 'n' steps forward without actually increasing the tokenstream index.

Parameter

i

Rückgabe

        {
 
            if (!More() || null == tokenStream[nextToken + i] )
                throw new ParserException("Es sind keine weiteren Token vorhanden.");
 
            return tokenStream[nextToken + i];
 
        }

Benutzt ScriptStack.Compiler.Parser.More(), ScriptStack.Compiler.Parser.nextToken und ScriptStack.Compiler.Parser.tokenStream.

◆ Member()

Variable ScriptStack.Compiler.Parser.Member ( )

private

Member access.

Rückgabe

        {
 
            string arrayIdentifier = ReadIdentifier();
 
            string tmp = null;
 
            while (LookAhead().Type == TokenType.Period)
            {
 
                ReadPeriod();
 
                string member = ReadIdentifier();
 
                tmp = AllocateTemporaryVariable();
 
                executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(tmp), Operand.MemberVariable(arrayIdentifier, member)));
 
                arrayIdentifier = tmp;
 
            }
 
            return new Variable(tmp, Scope.Local, null);
 
        }

Benutzt ScriptStack.Compiler.Parser.AllocateTemporaryVariable(), ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Runtime.Operand.MemberVariable(), ScriptStack.Compiler.Parser.ReadIdentifier(), ScriptStack.Compiler.Parser.ReadPeriod(), ScriptStack.Runtime.Variable und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Atom().

◆ MemberAssignment()

Variable ScriptStack.Compiler.Parser.MemberAssignment ( )

private

Rückgabe

        {
 
            string identifier = ExpectIdentifier();
 
            List<string> members = new List<string>();
 
            while (LookAhead().Type == TokenType.Period)
            {
 
                ReadPeriod();
 
                members.Add(ReadIdentifier());
 
            }
 
            Token tok = ReadToken();
 
            if (!AssignmentOperator(tok.Type))
                throw new ParserException("Ein Zuweisungsoperator wurde erwartet.", tok);
 
            Variable expression = Expression();
 
            string dst = null;
 
            string src = identifier;
 
            for (int i = 0; i < members.Count - 1; i++)
            {
 
                dst = AllocateTemporaryVariable();
 
                executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(dst), Operand.MemberVariable(src, members[i])));
 
                src = dst;
 
            }
 
            if (dst == null)
                dst = identifier;
 
            executable.InstructionsInternal.Add(new Instruction(AssignmentOpcode(tok.Type), Operand.MemberVariable(dst, members[members.Count - 1]), Operand.Variable(expression.name)));
 
            string tmpIdentifier = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(tmpIdentifier), Operand.MemberVariable(dst, members[members.Count - 1])));
 
            Variable variable = new Variable(tmpIdentifier, Scope.Local, expression.derivatedType);
 
            return variable;
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Assignment().

◆ More()

bool ScriptStack.Compiler.Parser.More ( )

private

Check if there are more tokens available.

Rückgabe

        {
            return nextToken < tokenStream.Count;
        }

Benutzt ScriptStack.Compiler.Parser.nextToken und ScriptStack.Compiler.Parser.tokenStream.

Wird benutzt von ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.ParseScript() und ScriptStack.Compiler.Parser.ReadToken().

◆ Not()

Variable ScriptStack.Compiler.Parser.Not ( )

private

Proposition.

May be a signed atom or a relation

Rückgabe

        {
 
            Variable proposition = new Variable();
 
            if (LookAhead().Type == TokenType.Not)
            {
 
                ReadToken();
 
                if (LookAhead().Type == TokenType.LeftParen)
                    proposition = Expression();
 
                else
                    proposition = Relation();
 
                executable.InstructionsInternal.Add(new Instruction(OpCode.NOT, Operand.Variable(proposition.name)));
 
                return proposition;
 
            }
 
            else
                return Relation();
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Expression(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Parser.Relation(), ScriptStack.Runtime.Variable und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.And().

◆ Notify()

void ScriptStack.Compiler.Parser.Notify ( )

private

Noch zu erledigen

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Notify)
                throw new ParserException("Keyword 'notify' erwartet.", token);
 
            string identifier = ExpectIdentifier();
 
            ReadSemicolon();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(identifier), Operand.Literal(true)));
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Runtime.Operand.Literal(), ScriptStack.Compiler.Parser.ReadSemicolon(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ Or()

Variable ScriptStack.Compiler.Parser.Or ( )

private

Disjunction (not exclusive)

Check for conjunction

Rückgabe

        {
 
            List<Instruction> instructions = executable.InstructionsInternal;
 
            Variable first = And();
 
            while (true)
            {
 
                Token token = ReadToken();
 
                if (token.Type == TokenType.Or)
                {
 
                    Variable second = And();
 
                    instructions.Add( new Instruction(OpCode.OR, Operand.Variable(first.name), Operand.Variable(second.name)));
 
                    first.derivatedType = Derivate(token, first.derivatedType, second.derivatedType);
 
                    break;
 
                }
 
                else
                {
 
                    UndoToken();
 
                    return first;
 
                }
 
            }
 
            return first;
 
        }

Benutzt ScriptStack.Compiler.Parser.And(), ScriptStack.Compiler.Parser.Derivate(), ScriptStack.Compiler.Parser.Variable.derivatedType, ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Compiler.Parser.UndoToken() und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Expression().

◆ Parse()

Executable ScriptStack.Compiler.Parser.Parse ( )

Parse the token stream into an executable.

Rückgabe

        {
            nextToken = 0;
            variables.Clear();
            localVariables.Clear();
            functionFrameIndex = -1;
            forwardDeclarations.Clear();
            loopControl.Clear();
 
            executable = new Executable(script);
 
            ParseScript();
            ResolveForwardFunctionDeclarations();
            executable.Clean();
 
            return executable;
        }

Benutzt ScriptStack.Runtime.Executable.Clean(), ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.forwardDeclarations, ScriptStack.Compiler.Parser.functionFrameIndex, ScriptStack.Compiler.Parser.localVariables, ScriptStack.Compiler.Parser.loopControl, ScriptStack.Compiler.Parser.nextToken, ScriptStack.Compiler.Parser.ParseScript(), ScriptStack.Compiler.Parser.ResolveForwardFunctionDeclarations(), ScriptStack.Compiler.Parser.script und ScriptStack.Compiler.Parser.variables.

◆ ParseScript()

void ScriptStack.Compiler.Parser.ParseScript ( )

private

After the first function declaration no more variable, struct or enum declarations are allowed anymore.

Noch zu erledigen

        {
 
            while (More())
            {
 
                Token token = LookAhead();
 
                if (token.Type == TokenType.Shared || token.Type == TokenType.Var)
                    VariableDeclaration();
 
                else if (token.Type == TokenType.Struct)
                    StructDeclaration();
 
                else if (token.Type == TokenType.Enum)
                    EnumDeclaration();
 
                else
                    break;
 
            }
 
            if (!More())
                return;
 
            while (More())
            {
 
                Token token = LookAhead();
 
                if (token.Type != TokenType.Function)
                    throw new ParserException( "Ausserhalb von Funktionen sind keine Anweisungen erlaubt.", token);
 
                FunctionDeclaration();
 
            }
 
        }

Benutzt ScriptStack.Compiler.Parser.EnumDeclaration(), ScriptStack.Compiler.Parser.FunctionDeclaration(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.More(), ScriptStack.Compiler.Parser.StructDeclaration(), ScriptStack.Compiler.Token.Type und ScriptStack.Compiler.Parser.VariableDeclaration().

Wird benutzt von ScriptStack.Compiler.Parser.Parse().

◆ Pointer()

Variable ScriptStack.Compiler.Parser.Pointer ( )

private

Array access.

like

var arr = [1, 2, 3];

print(arr[1]); // the brackets are the array access

Noch zu erledigen: rename this! its not a pointer

Rückgabe

        {
 
            string identifier = ReadIdentifier();
 
            string tmp = null;
 
            while (LookAhead().Type == TokenType.LeftBracket)
            {
 
                ReadLeftBracket();
 
                Variable index = Expression();
 
                ReadRightBracket();
 
                tmp = AllocateTemporaryVariable();
 
                executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(tmp), Operand.CreatePointer(identifier, index.name)));
 
                identifier = tmp;
 
            }
 
            return new Variable(tmp, Scope.Local, null);
 
        }

Benutzt ScriptStack.Compiler.Parser.AllocateTemporaryVariable(), ScriptStack.Runtime.Operand.CreatePointer(), ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Expression(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadIdentifier(), ScriptStack.Compiler.Parser.ReadLeftBracket(), ScriptStack.Compiler.Parser.ReadRightBracket(), ScriptStack.Runtime.Variable und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Atom().

◆ PostDecrement()

Variable ScriptStack.Compiler.Parser.PostDecrement ( )

private

Rückgabe

        {
 
            string identifier = ExpectIdentifier();
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Decrement)
                throw new ParserException("Post-decrement '--' erwartet.", token);
 
            string tmp = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(tmp), Operand.Variable(identifier)));
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.DEC, Operand.Variable(identifier)));
 
            return new Variable(tmp, Scope.Local, null);
 
        }

Benutzt ScriptStack.Compiler.Parser.AllocateTemporaryVariable(), ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Variable und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Atom().

◆ PostIncrement()

Variable ScriptStack.Compiler.Parser.PostIncrement ( )

private

Rückgabe

        {
 
            string identifier = ExpectIdentifier();
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Increment)
                throw new ParserException("Post-increment '++' erwartet.", token);
 
            string tmp = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(tmp), Operand.Variable(identifier)));
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.INC, Operand.Variable(identifier)));
 
            return new Variable(tmp, Scope.Local, null);
 
        }

Benutzt ScriptStack.Compiler.Parser.AllocateTemporaryVariable(), ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Variable und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Atom().

◆ PreDecrement()

Variable ScriptStack.Compiler.Parser.PreDecrement ( )

private

Rückgabe

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Decrement)
                throw new ParserException("Pre-decrement '--' erwartet.", token);
 
            string identifier = ExpectIdentifier();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.DEC, Operand.Variable(identifier)));
 
            return new Variable(identifier, Scope.Local, null);
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Variable und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Atom().

◆ PreIncrement()

Variable ScriptStack.Compiler.Parser.PreIncrement ( )

private

Rückgabe

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Increment)
                throw new ParserException( "Pre-increment '++' erwartet.", token);
 
            string identifier = ExpectIdentifier();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.INC, Operand.Variable(identifier)));
 
            return new Variable(identifier, Scope.Local, null);
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Variable und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Atom().

◆ ReadComma()

void ScriptStack.Compiler.Parser.ReadComma ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Comma)
                throw new ParserException("Comma ',' erwartet.", token);
 
        }

Benutzt ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.BraceArray(), ScriptStack.Compiler.Parser.BracketArray(), ScriptStack.Compiler.Parser.EnumDeclaration(), ScriptStack.Compiler.Parser.FunctionCall(), ScriptStack.Compiler.Parser.FunctionDeclaration(), ScriptStack.Compiler.Parser.RoutineCall() und ScriptStack.Compiler.Parser.StructDeclaration().

◆ ReadIdentifier()

string ScriptStack.Compiler.Parser.ReadIdentifier ( )

private

Read a new (previously NOT declared) identifier.

Rückgabe

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Identifier)
                throw new ParserException("Ein Keyword oder eine Variable wurde erwartet.", token);
 
            return token.Lexeme.ToString();
 
        }

Benutzt ScriptStack.Compiler.Token.Lexeme, ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

◆ ReadLeftBrace()

void ScriptStack.Compiler.Parser.ReadLeftBrace ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.LeftBrace)
                throw new ParserException("Geschwungene Klammer '{' erwartet.", token);
 
        }

Benutzt ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.BraceArray(), ScriptStack.Compiler.Parser.EnumDeclaration(), ScriptStack.Compiler.Parser.StructDeclaration() und ScriptStack.Compiler.Parser.Switch().

◆ ReadLeftBracket()

void ScriptStack.Compiler.Parser.ReadLeftBracket ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.LeftBracket)
                throw new ParserException("Eckige Klammer '[' erwartet.", token);
 
        }

Benutzt ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.ArrayAssignment(), ScriptStack.Compiler.Parser.BracketArray(), ScriptStack.Compiler.Parser.IsPointer() und ScriptStack.Compiler.Parser.Pointer().

◆ ReadLeftParenthesis()

void ScriptStack.Compiler.Parser.ReadLeftParenthesis ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.LeftParen)
                throw new ParserException("Klammer '(' erwartet.", token);
 
        }

Benutzt ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.For(), ScriptStack.Compiler.Parser.ForEach(), ScriptStack.Compiler.Parser.FunctionCall(), ScriptStack.Compiler.Parser.FunctionDeclaration(), ScriptStack.Compiler.Parser.If(), ScriptStack.Compiler.Parser.RoutineCall(), ScriptStack.Compiler.Parser.Switch() und ScriptStack.Compiler.Parser.While().

◆ ReadPeriod()

void ScriptStack.Compiler.Parser.ReadPeriod ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Period)
                throw new ParserException("Punkt '.' erwartet.", token);
 
        }

Benutzt ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.IsMember(), ScriptStack.Compiler.Parser.Member() und ScriptStack.Compiler.Parser.MemberAssignment().

◆ ReadRightBrace()

void ScriptStack.Compiler.Parser.ReadRightBrace ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.RightBrace)
                throw new ParserException("Geschwungene Klammer '}' erwartet.", token);
 
        }

Benutzt ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.BraceArray(), ScriptStack.Compiler.Parser.EnumDeclaration(), ScriptStack.Compiler.Parser.StatementList(), ScriptStack.Compiler.Parser.StructDeclaration() und ScriptStack.Compiler.Parser.Switch().

◆ ReadRightBracket()

void ScriptStack.Compiler.Parser.ReadRightBracket ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.RightBracket)
                throw new ParserException("Eckige Klammer ']' erwartet.", token);
 
        }

Benutzt ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.ArrayAssignment(), ScriptStack.Compiler.Parser.BracketArray(), ScriptStack.Compiler.Parser.IsPointer() und ScriptStack.Compiler.Parser.Pointer().

◆ ReadRightParenthesis()

void ScriptStack.Compiler.Parser.ReadRightParenthesis ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.RightParen)
                throw new ParserException("Klammer ')' erwartet.", token);
 
        }

Benutzt ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.Atom(), ScriptStack.Compiler.Parser.For(), ScriptStack.Compiler.Parser.ForEach(), ScriptStack.Compiler.Parser.FunctionCall(), ScriptStack.Compiler.Parser.FunctionDeclaration(), ScriptStack.Compiler.Parser.If(), ScriptStack.Compiler.Parser.RoutineCall(), ScriptStack.Compiler.Parser.Switch() und ScriptStack.Compiler.Parser.While().

◆ ReadSemicolon()

void ScriptStack.Compiler.Parser.ReadSemicolon ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.SemiColon)
                throw new ParserException("Semicolon ';' erwartet.", token);
 
        }

Benutzt ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.BraceArray(), ScriptStack.Compiler.Parser.Break(), ScriptStack.Compiler.Parser.Continue(), ScriptStack.Compiler.Parser.For(), ScriptStack.Compiler.Parser.Notify(), ScriptStack.Compiler.Parser.Return(), ScriptStack.Compiler.Parser.Run(), ScriptStack.Compiler.Parser.Statement(), ScriptStack.Compiler.Parser.Wait() und ScriptStack.Compiler.Parser.Yield().

◆ ReadToken()

Token ScriptStack.Compiler.Parser.ReadToken ( )

private

Get the next available token.

Rückgabe

        {
 
            if (!More())
                throw new ParserException("Es sind keine weiteren Token vorhanden.");
 
            return tokenStream[nextToken++];
 
        }

Benutzt ScriptStack.Compiler.Parser.More(), ScriptStack.Compiler.Parser.nextToken und ScriptStack.Compiler.Parser.tokenStream.

◆ Relation()

Variable ScriptStack.Compiler.Parser.Relation ( )

private

Rückgabe

        {
 
            List<Instruction> instructions = executable.InstructionsInternal;
 
            Variable first = Arithmetic();
 
            Token token = ReadToken();
 
            if (RelationalOperator(token.Type)) {
 
                Variable second = Arithmetic();
 
                instructions.Add(new Instruction(RelationalOpcode(token.Type), Operand.Variable(first.name), Operand.Variable(second.name)));
 
                first.derivatedType = Derivate(token, first.derivatedType, second.derivatedType);
 
            }
 
            else
                UndoToken();
 
            return first;
 
        }

Benutzt ScriptStack.Compiler.Parser.Arithmetic(), ScriptStack.Compiler.Parser.Derivate(), ScriptStack.Compiler.Parser.Variable.derivatedType, ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Parser.RelationalOpcode(), ScriptStack.Compiler.Parser.RelationalOperator(), ScriptStack.Compiler.Token.Type, ScriptStack.Compiler.Parser.UndoToken() und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Not().

◆ RelationalOpcode()

OpCode ScriptStack.Compiler.Parser.RelationalOpcode ( TokenType tokenType )

private

Parameter

tokenType

Rückgabe

        {
 
            switch (tokenType)
            {
 
                case TokenType.Equal: return OpCode.CEQ;
                case TokenType.NotEqual: return OpCode.CNE;
                case TokenType.Greater: return OpCode.CG;
                case TokenType.GreaterEqual: return OpCode.CGE;
                case TokenType.Less: return OpCode.CL;
                case TokenType.LessEqual: return OpCode.CLE;
                default:
                    throw new ParserException("Der Token '" + tokenType + "' ist kein relationaler Operator.");
 
            }
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Relation().

◆ RelationalOperator()

bool ScriptStack.Compiler.Parser.RelationalOperator ( TokenType tokenType )

private

Parameter

tokenType

Rückgabe

        {
 
            switch (tokenType)
            {
 
                case TokenType.Equal:
                case TokenType.NotEqual:
                case TokenType.Greater:
                case TokenType.GreaterEqual:
                case TokenType.Less:
                case TokenType.LessEqual:
                    return true;
 
                default:
                    return false;
 
            }
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Relation().

◆ ResolveForwardFunctionDeclarations()

void ScriptStack.Compiler.Parser.ResolveForwardFunctionDeclarations ( )

private

Resolve unresolved, forward declared functions.

        {
 
            foreach (Instruction instruction in forwardDeclarations.Keys)
            {
 
                FunctionDescriptor functionDescriptor = forwardDeclarations[instruction];
 
                string name = functionDescriptor.name;
 
                if (!executable.Functions.ContainsKey(name))
                    throw new ParserException("Eine nicht deklarierte Funktion '" + name + "' wurde referenziert.");
 
                Function function = executable.Functions[name];
 
                instruction.First.FunctionPointer = function;
 
            }
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.forwardDeclarations, ScriptStack.Runtime.Executable.Functions und ScriptStack.Compiler.Parser.FunctionDescriptor.name.

Wird benutzt von ScriptStack.Compiler.Parser.Parse().

◆ Return()

void ScriptStack.Compiler.Parser.Return ( )

private

By default null is returned.

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Return)
                throw new ParserException("Keyword 'return' erwartet.", token);
 
            if (LookAhead().Type != TokenType.SemiColon)
                executable.InstructionsInternal.Add(new Instruction(OpCode.PUSH, Operand.Variable(Expression().name)));
 
            else
                executable.InstructionsInternal.Add(new Instruction(OpCode.PUSH, Operand.Literal(NullReference.Instance)));
 
            ReadSemicolon();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.RET));
 
            return;
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Expression(), ScriptStack.Runtime.Operand.Literal(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.ReadSemicolon(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ RoutineCall()

Variable ScriptStack.Compiler.Parser.RoutineCall ( )

private

Noch zu erledigen: Run routines in background? bad for cloud

Rückgabe

        {
 
            string identifier = ReadIdentifier();
 
            ReadLeftParenthesis();
 
            List<object> parameters = new List<object>();
 
            int parameterCount = 0;
 
            if (LookAhead().Type != TokenType.RightParen)
            {
 
                while (true)
                {
 
                    Variable parameter = Expression();
 
                    executable.InstructionsInternal.Add(new Instruction( OpCode.PUSH, Operand.Variable(parameter.name)));
 
                    ++parameterCount;
 
                    if (LookAhead().Type == TokenType.RightParen)
                        break;
 
                    else
                        ReadComma();
 
                }
 
            }
 
            ReadRightParenthesis();
 
            Manager manager = executable.Script.Manager;
 
            if (!manager.Routines.ContainsKey(identifier))
                throw new ParserException("Die Routine '" + identifier + "' ist nicht vorhanden.");
 
            Routine routine = manager.Routines[identifier];
 
            if (routine.ParameterTypes.Count > parameterCount)
                throw new ParserException("Der Aufruf der Routine '" + identifier + "' hat fehlende Parameter. Erwartet werden " + routine.ParameterTypes.Count + " Parameter.\nBeschreibung der Routine: " + routine.Description().ToString());
 
            if (routine.ParameterTypes.Count < parameterCount)
                throw new ParserException("Der Aufruf der Routine '" + identifier + "' hat zu viele Parameter. Erwartet werden " + routine.ParameterTypes.Count + " Parameter.\nBeschreibung der Routine: " + routine.Description().ToString());
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.INV, Operand.AllocateRoutinePointer(routine)));
 
            Variable variable = new Variable
            {
                name = AllocateTemporaryVariable(),
                scope = Scope.Local,
                derivatedType = null
            };
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.POP, Operand.Variable(variable.name)));
 
            return variable;
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.FunctionCall().

◆ Run()

void ScriptStack.Compiler.Parser.Run ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Run)
                throw new ParserException("Keyword 'run' erwartet.", token);
 
            FunctionCall(true);
 
            ReadSemicolon();
 
        }

Benutzt ScriptStack.Compiler.Parser.FunctionCall(), ScriptStack.Compiler.Parser.ReadSemicolon(), ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ ShiftLeft()

Variable ScriptStack.Compiler.Parser.ShiftLeft ( )

private

Rückgabe

        {
 
            string left = ExpectIdentifier();
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.ShiftLeft)
                throw new ParserException("Shift Left '<<' erwartet.", token);
 
            Variable right = Factor();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.SHL, Operand.Variable(left), Operand.Variable(right.name)));
 
            return right;
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.Factor(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Atom().

◆ ShiftRight()

Variable ScriptStack.Compiler.Parser.ShiftRight ( )

private

Rückgabe

        {
 
            string left = ExpectIdentifier();
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.ShiftRight)
                throw new ParserException("Shift Right '>>' erwartet.", token);
 
            Variable right = Factor();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.SHR, Operand.Variable(left), Operand.Variable(right.name)));
 
            return right;
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.Factor(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Atom().

◆ Statement()

void ScriptStack.Compiler.Parser.Statement ( )

private

A statement can be a local variable declaration, a statement list, an expression or a keyword.

        {
 
            AllocateFunctionFrame();
 
            Token token = LookAhead();
 
            InsertDebugInfo(token);
 
            switch (token.Type)
            {
 
                case TokenType.SemiColon:
                    ReadToken();
                    break;
 
                case TokenType.Var:
                    LocalVariableDeclaration();
                    break;
 
                case TokenType.LeftBrace:
                    StatementList();
                    break;
 
                case TokenType.Increment:
                case TokenType.Decrement:
                case TokenType.LeftParen:
                case TokenType.Identifier:
                case TokenType.Null:
                case TokenType.Integer:
                case TokenType.Float:
                case TokenType.Boolean:
                case TokenType.String:
                case TokenType.Char:
                    Expression();
                    if(LookAhead().Type == TokenType.SemiColon)
                        ReadSemicolon();
                    break;
 
                case TokenType.If:
                    If();
                    break;
                case TokenType.While:
                    While();
                    break;
                case TokenType.For:
                    For();
                    break;
                case TokenType.Foreach:
                    ForEach();
                    break;
                case TokenType.Break:
                    Break();
                    break;
                case TokenType.Continue:
                    Continue();
                    break;
                case TokenType.Switch:
                    Switch();
                    break;
                case TokenType.Return:
                    Return();
                    break;
 
                case TokenType.Run:
                    Run();
                    break;
                case TokenType.Yield:
                    Yield();
                    break;
                case TokenType.Wait:
                    Wait();
                    break;
                case TokenType.Notify:
                    Notify();
                    break;
                case TokenType.Lock:
                    LockedStatementList();
                    break;
 
                default: throw new ParserException("ParserException::Statement: Ein unerwarteter Token '" + token.Lexeme + "' wurde gefunden.", token);
 
            }
 
            FreeFunctionFrame();
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.LockedStatementList(), ScriptStack.Compiler.Parser.StatementList() und ScriptStack.Compiler.Parser.Switch().

◆ StatementList()

void ScriptStack.Compiler.Parser.StatementList ( )

private

A list of statements. If its not a list (not in braces) just return a single statement.

        {
 
            // if there are no braces, just read a single statement
            if (LookAhead().Type != TokenType.LeftBrace)
            {
 
                Statement();
 
                return;
 
            }
 
            ReadToken();
 
            while (LookAhead().Type != TokenType.RightBrace)
                Statement();
 
            ReadRightBrace();
 
        }

Benutzt ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.ReadRightBrace(), ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Parser.Statement().

Wird benutzt von ScriptStack.Compiler.Parser.For(), ScriptStack.Compiler.Parser.ForEach(), ScriptStack.Compiler.Parser.FunctionDeclaration(), ScriptStack.Compiler.Parser.If(), ScriptStack.Compiler.Parser.Statement() und ScriptStack.Compiler.Parser.While().

◆ StructDeclaration()

Variable ScriptStack.Compiler.Parser.StructDeclaration ( )

private

In fact a struct by now is just an array with pre defined member names. It is stored at the scripts local memory.

Noch zu erledigen: struct is in beta

        {
 
            AllocateFunctionFrame();
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Struct)
                throw new ParserException("Strukturen werden mit 'struct' deklariert.", token);
 
            InsertDebugInfo(token);
 
            string identifier = ReadIdentifier();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.DCO, Operand.Variable(identifier)));
 
            string alloc = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(alloc), Operand.Variable(identifier)));
 
            variables[identifier] = true;
 
            ArrayList array = new ArrayList();
 
            ReadLeftBrace();
 
            int i = 0;
 
            while (true)
            {
 
                Token tok = ReadToken();
 
                if (tok.Type == TokenType.RightBrace)
                {
 
                    UndoToken();
                    break;
 
                }
 
                if (LookAhead().Type == TokenType.RightBrace)
                {
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.ADD, Operand.CreatePointer(identifier, (string)tok.Lexeme), Operand.Literal(0)));
                    array.Add(tok.Lexeme, 0);
                    break;
 
                }
 
                else if (LookAhead().Type == TokenType.Colon)
                {
 
                    ReadToken();
 
                    Token tmpToken = ReadToken();
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.ADD, Operand.CreatePointer(identifier, (string)tok.Lexeme), Operand.Variable(tmpToken.Lexeme.ToString())));
 
                    array.Add(tok.Lexeme, tmpToken.Lexeme);
 
                }
 
                else
                {
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.ADD, Operand.CreatePointer(identifier, (string)tok.Lexeme), Operand.Literal(0)));
 
                    array.Add(tok.Lexeme, 0);
 
                }
 
                if (LookAhead().Type == TokenType.RightBrace)
                    break;
 
                ReadComma();
 
                i++;
 
            }
 
            ReadRightBrace();
 
            executable.ScriptMemory[identifier] = array;
 
            FreeFunctionFrame();
 
            return new Variable(identifier, Scope.Local, typeof(ArrayList));
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.ParseScript().

◆ Switch()

void ScriptStack.Compiler.Parser.Switch ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Switch)
                throw new ParserException("Keyword 'switch' erwartet.", token);
 
            ReadLeftParenthesis();
 
            string switchIdentifier = ExpectIdentifier();
 
            ReadRightParenthesis();
 
            ReadLeftBrace();
 
            token = LookAhead();
 
            if (token.Type != TokenType.Case && token.Type != TokenType.Default)
                throw new ParserException("Keyword 'case' oder 'default' erwartet.", token);
 
            string tmpIdentifier = AllocateTemporaryVariable();
 
            string identifier = AllocateTemporaryVariable();
 
            Instruction end = new Instruction(OpCode.NOP);
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(tmpIdentifier), Operand.Literal(false)));
 
            while (LookAhead().Type != TokenType.Default && LookAhead().Type != TokenType.RightBrace)
            {
 
                token = ReadToken();
 
                if (token.Type != TokenType.Case)
                    throw new ParserException("Keyword 'case' erwartet.", token);
 
                InsertDebugInfo(token);
 
                Variable expression = Expression();
 
                token = ReadToken();
 
                if (token.Type != TokenType.Colon)
                    throw new ParserException("Colon ':' erwartet.", token);
 
                executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(identifier), Operand.Variable(switchIdentifier)));
 
                executable.InstructionsInternal.Add(new Instruction(OpCode.CEQ, Operand.Variable(identifier), Operand.Variable(expression.name)));
 
                executable.InstructionsInternal.Add(new Instruction(OpCode.OR,  Operand.Variable(tmpIdentifier),  Operand.Variable(identifier)));
 
                if (LookAhead().Type != TokenType.Case)
                {
                    Instruction switchInstruction = new Instruction(OpCode.NOP);
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.JNZ, Operand.Variable(tmpIdentifier), Operand.AllocateInstructionPointer(switchInstruction)));
 
                    Statement();
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.JMP, Operand.AllocateInstructionPointer(end)));
 
                    executable.InstructionsInternal.Add(switchInstruction);
 
                    executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(tmpIdentifier), Operand.Literal(false)));
 
                }
            }
 
            token = ReadToken();
 
            if (token.Type == TokenType.RightBrace)
            {
 
                executable.InstructionsInternal.Add(end);
 
                return;
 
            }
 
            if (token.Type != TokenType.Default)
                throw new ParserException("Das Keyword 'default' oder eine schliessende geschwungene Klammer '}' wird am Ende einer 'switch' Anweisung erwartet.", token);
 
            token = ReadToken();
 
            if (token.Type != TokenType.Colon)
                throw new ParserException("Ein Colon ':' wurde erwartet.", token);
 
            Statement();
 
            ReadRightBrace();
 
            executable.InstructionsInternal.Add(end);
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ Term()

Variable ScriptStack.Compiler.Parser.Term ( )

private

Factor ( [*|/|%] Factor )

Rückgabe

        {
 
            List<Instruction> listInstructions = executable.InstructionsInternal;
 
            Variable first = Factor();
 
            Variable second = new Variable();
 
            while (true)
            {
 
                Token token = ReadToken();
 
                switch (token.Type)
                {
 
                    case TokenType.Multiply:
                        second = Factor();
 
                        listInstructions.Add(new Instruction(OpCode.MUL, Operand.Variable(first.name), Operand.Variable(second.name)));
 
                        first.derivatedType = Derivate(token, first.derivatedType, second.derivatedType);
 
                        break;
 
                    case TokenType.Divide:
 
                        second = Factor();
 
                        listInstructions.Add(new Instruction(OpCode.DIV, Operand.Variable(first.name), Operand.Variable(second.name)));
 
                        first.derivatedType = Derivate(token, first.derivatedType, second.derivatedType);
 
                        break;
 
                    case TokenType.Modulo:
                        second = Factor();
 
                        listInstructions.Add(new Instruction(OpCode.MOD, Operand.Variable(first.name), Operand.Variable(second.name)));
 
                        first.derivatedType = Derivate(token, first.derivatedType, second.derivatedType);
 
                        break;
 
                    default:
                        UndoToken();
                        return first;
 
                }
 
            }
 
        }

Benutzt ScriptStack.Compiler.Parser.Derivate(), ScriptStack.Compiler.Parser.Variable.derivatedType, ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.Factor(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Compiler.Parser.UndoToken(), ScriptStack.Runtime.Variable und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Arithmetic().

◆ ToLiteral()

string ScriptStack.Compiler.Parser.ToLiteral ( string input )

        {
            var literal = new StringBuilder(input.Length + 2);
            literal.Append("\"");
            foreach (var c in input)
            {
                switch (c)
                {
                    case '\'': literal.Append(@"\'"); break;
                    case '\"': literal.Append("\\\""); break;
                    case '\\': literal.Append(@"\\"); break;
                    case '\0': literal.Append(@"\0"); break;
                    case '\a': literal.Append(@"\a"); break;
                    case '\b': literal.Append(@"\b"); break;
                    case '\f': literal.Append(@"\f"); break;
                    case '\n': literal.Append(@"\n"); break;
                    case '\r': literal.Append(@"\r"); break;
                    case '\t': literal.Append(@"\t"); break;
                    case '\v': literal.Append(@"\v"); break;
                    default:
                        if (char.GetUnicodeCategory(c) != System.Globalization.UnicodeCategory.Control)
                        {
                            literal.Append(c);
                        }
                        else
                        {
                            literal.Append(@"\u");
                            literal.Append(((ushort)c).ToString("x4"));
                        }
                        break;
                }
            }
            literal.Append("\"");
            return literal.ToString();
        }

◆ UndoToken()

void ScriptStack.Compiler.Parser.UndoToken ( )

private

If you read a token wrong, push it back so the stream stays intact.

        {
 
            if (nextToken <= 0)
                throw new ParserException("Es sind keine vorangehenden Token mehr vorhanden.");
 
            --nextToken;
 
        }

Benutzt ScriptStack.Compiler.Parser.nextToken.

◆ VariableAssignment()

Variable ScriptStack.Compiler.Parser.VariableAssignment ( )

private

Rückgabe

        {
 
            string identifier = ExpectIdentifier();
 
            Token token = ReadToken();
 
            if (!AssignmentOperator(token.Type))
                throw new ParserException("Ein Zuweisungsoperator wurde erwartet erwartet.", token);
 
            Variable expression = Expression();
 
            executable.InstructionsInternal.Add(new Instruction(AssignmentOpcode(token.Type), Operand.Variable(identifier), Operand.Variable(expression.name)));
 
            string tmpIdentifier = AllocateTemporaryVariable();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.MOV, Operand.Variable(tmpIdentifier), Operand.Variable(identifier)));
 
            return new Variable(tmpIdentifier, Scope.Local, expression.derivatedType);
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Assignment().

◆ VariableDeclaration()

void ScriptStack.Compiler.Parser.VariableDeclaration ( )

private

Shared or local variable declaration.

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Shared && token.Type != TokenType.Var)
                throw new ParserException( "Variablen werden mit 'shared' oder 'var' deklariert.", token);
 
            InsertDebugInfo(token);
 
            OpCode opcode = OpCode.DB;
 
            if(token.Type == TokenType.Shared)
                opcode = OpCode.DSB;
 
            string identifier = ReadIdentifier();
 
            while (true)
            {
 
                if (variables.ContainsKey(identifier))
                    throw new ParserException( "Die Variable '" + identifier + "' ist bereits vorhanden.", token);
 
                variables[identifier] = true;
 
                executable.InstructionsInternal.Add(new Instruction(opcode, Operand.Variable(identifier)));
 
                if (opcode == OpCode.DSB)
                    script.Manager.SharedMemory[identifier] = NullReference.Instance;
 
                else
                    executable.ScriptMemory[identifier] = NullReference.Instance;
 
                token = ReadToken();
 
                if (token.Type == TokenType.SemiColon)
                    return;
 
                if (token.Type != TokenType.Comma)
                    throw new ParserException("Comma ',' erwartet.", token);
 
                identifier = ReadIdentifier();
 
            }
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.InsertDebugInfo(), ScriptStack.Runtime.Script.Manager, ScriptStack.Compiler.Parser.ReadIdentifier(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Parser.script, ScriptStack.Runtime.Executable.ScriptMemory, ScriptStack.Manager.SharedMemory, ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable() und ScriptStack.Compiler.Parser.variables.

Wird benutzt von ScriptStack.Compiler.Parser.ParseScript().

◆ Wait()

void ScriptStack.Compiler.Parser.Wait ( )

private

Wait for a locked secion of code to be freed.

Noch zu erledigen

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Wait)
                throw new ParserException("Keyword 'wailt' erwartet.", token);
 
            string identifier = ExpectIdentifier();
 
            ReadSemicolon();
 
            List<Instruction> instructions = executable.InstructionsInternal;
 
            Instruction arrived = new Instruction(OpCode.NOP);
 
            Instruction waiting = new Instruction(OpCode.JZ, Operand.Variable(identifier), Operand.AllocateInstructionPointer(arrived));
 
            instructions.Add(waiting);
 
            instructions.Add(new Instruction(OpCode.INT));
 
            instructions.Add(new Instruction(OpCode.JMP, Operand.AllocateInstructionPointer(waiting)));
 
            instructions.Add(arrived);
 
        }

Benutzt ScriptStack.Runtime.Operand.AllocateInstructionPointer(), ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.ReadSemicolon(), ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ While()

void ScriptStack.Compiler.Parser.While ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.While)
                throw new ParserException("Keyword 'while' erwartet.", token);
 
            Instruction start = new Instruction(OpCode.NOP);
 
            executable.InstructionsInternal.Add(start);
 
            ReadLeftParenthesis();
 
            Variable condition = Expression();
 
            if (condition.derivatedType != null && condition.derivatedType != typeof(bool))
                throw new ParserException("In While Loops wird ein logischer Ausdruck erwartet.", token);
 
            ReadRightParenthesis();
 
            Instruction end = new Instruction(OpCode.NOP);
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.JNZ, Operand.Variable(condition.name), Operand.AllocateInstructionPointer(end)));
 
            LoopControl loopControl = new LoopControl();
 
            loopControl.Break = end;
 
            loopControl.Continue = start;
 
            this.loopControl.Push(loopControl);
 
            StatementList();
 
            this.loopControl.Pop();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.JMP, Operand.AllocateInstructionPointer(start)));
 
            executable.InstructionsInternal.Add(end);
 
        }

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

◆ Xor()

Variable ScriptStack.Compiler.Parser.Xor ( )

private

Rückgabe

        {
 
            string left = ExpectIdentifier();
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.AssignXor)
                throw new ParserException("Binary XOR '~=' erwartet.", token);
 
            Variable right = Factor();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.XOR, Operand.Variable(left), Operand.Variable(right.name)));
 
            return right;
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.Factor(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Compiler.Parser.ReadToken(), ScriptStack.Compiler.Token.Type und ScriptStack.Runtime.Operand.Variable().

◆ Yield()

void ScriptStack.Compiler.Parser.Yield ( )

private

        {
 
            Token token = ReadToken();
 
            if (token.Type != TokenType.Yield)
                throw new ParserException("ParserException: Keyword 'yield' erwartet.", token);
 
            ReadSemicolon();
 
            executable.InstructionsInternal.Add(new Instruction(OpCode.INT));
 
        }

Benutzt ScriptStack.Compiler.Parser.executable, ScriptStack.Compiler.Parser.ReadSemicolon(), ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Token.Type.

Wird benutzt von ScriptStack.Compiler.Parser.Statement().

Dokumentation der Datenelemente

◆ debugMode

bool ScriptStack.Compiler.Parser.debugMode

private

Wird benutzt von ScriptStack.Compiler.Parser.InsertDebugInfo() und ScriptStack.Compiler.Parser.Parser().

◆ derivation

Derivation ScriptStack.Compiler.Parser.derivation

private

Wird benutzt von ScriptStack.Compiler.Parser.Derivate() und ScriptStack.Compiler.Parser.Parser().

◆ executable

Executable ScriptStack.Compiler.Parser.executable

private

◆ forwardDeclarations

Dictionary<Instruction, FunctionDescriptor> ScriptStack.Compiler.Parser.forwardDeclarations

private

Wird benutzt von ScriptStack.Compiler.Parser.FunctionCall(), ScriptStack.Compiler.Parser.Parse(), ScriptStack.Compiler.Parser.Parser() und ScriptStack.Compiler.Parser.ResolveForwardFunctionDeclarations().

◆ functionFrameIndex

int ScriptStack.Compiler.Parser.functionFrameIndex

private

Wird benutzt von ScriptStack.Compiler.Parser.AllocateFunctionFrame(), ScriptStack.Compiler.Parser.AllocateTemporaryVariable(), ScriptStack.Compiler.Parser.FreeFunctionFrame(), ScriptStack.Compiler.Parser.Parse() und ScriptStack.Compiler.Parser.Parser().

◆ localVariables

Dictionary<string, bool> ScriptStack.Compiler.Parser.localVariables

private

Wird benutzt von ScriptStack.Compiler.Parser.AllocateTemporaryVariable(), ScriptStack.Compiler.Parser.AllocateVariable(), ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.FreeFunctionFrame(), ScriptStack.Compiler.Parser.FunctionDeclaration(), ScriptStack.Compiler.Parser.Parse() und ScriptStack.Compiler.Parser.Parser().

◆ loopControl

Stack<LoopControl> ScriptStack.Compiler.Parser.loopControl

private

Wird benutzt von ScriptStack.Compiler.Parser.Break(), ScriptStack.Compiler.Parser.Continue(), ScriptStack.Compiler.Parser.For(), ScriptStack.Compiler.Parser.ForEach(), ScriptStack.Compiler.Parser.Parse(), ScriptStack.Compiler.Parser.Parser() und ScriptStack.Compiler.Parser.While().

◆ nextToken

int ScriptStack.Compiler.Parser.nextToken

private

Wird benutzt von ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.More(), ScriptStack.Compiler.Parser.Parse(), ScriptStack.Compiler.Parser.Parser(), ScriptStack.Compiler.Parser.ReadToken() und ScriptStack.Compiler.Parser.UndoToken().

◆ script

Script ScriptStack.Compiler.Parser.script

private

Wird benutzt von ScriptStack.Compiler.Parser.Parse(), ScriptStack.Compiler.Parser.Parser() und ScriptStack.Compiler.Parser.VariableDeclaration().

◆ tokenStream

List<Token> ScriptStack.Compiler.Parser.tokenStream

private

Wird benutzt von ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.LookAhead(), ScriptStack.Compiler.Parser.More(), ScriptStack.Compiler.Parser.Parser() und ScriptStack.Compiler.Parser.ReadToken().

◆ variables

Dictionary<string, bool> ScriptStack.Compiler.Parser.variables

private

Wird benutzt von ScriptStack.Compiler.Parser.AllocateTemporaryVariable(), ScriptStack.Compiler.Parser.AllocateVariable(), ScriptStack.Compiler.Parser.EnumDeclaration(), ScriptStack.Compiler.Parser.ExpectIdentifier(), ScriptStack.Compiler.Parser.Parse(), ScriptStack.Compiler.Parser.Parser(), ScriptStack.Compiler.Parser.StructDeclaration() und ScriptStack.Compiler.Parser.VariableDeclaration().

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

C:/Users/manuel/Desktop/doc/Compiler/Parser.cs

Klassen

Öffentliche Methoden

Private Methoden

Private Attribute

Ausführliche Beschreibung

Beschreibung der Konstruktoren und Destruktoren

◆ Parser()

Dokumentation der Elementfunktionen

◆ AllocateFunctionFrame()

◆ AllocateTemporaryVariable()

◆ AllocateVariable()

◆ And()

◆ Arithmetic()

◆ ArrayAssignment()

◆ Assignment()

◆ AssignmentOpcode()

◆ AssignmentOperator()

◆ Atom()

◆ BinaryAnd()

◆ BinaryNot()

◆ BinaryNotAssign()

◆ BinaryOr()

◆ BraceArray()

◆ BracketArray()

◆ Break()

◆ Continue()

◆ Derivate()

◆ EnumDeclaration()

◆ ExpectIdentifier()

◆ Expression()

◆ Factor()

◆ For()

◆ ForEach()

◆ FreeFunctionFrame()

◆ FunctionCall() [1/2]

◆ FunctionCall() [2/2]

◆ FunctionDeclaration()

◆ If()

◆ InsertDebugInfo()

◆ IsMember()

◆ IsPointer()

◆ Literal()

◆ LocalVariableDeclaration()

◆ LockedStatementList()

◆ LookAhead() [1/2]

◆ LookAhead() [2/2]

◆ Member()

◆ MemberAssignment()

◆ More()

◆ Not()

◆ Notify()

◆ Or()

◆ Parse()

◆ ParseScript()

◆ Pointer()

◆ PostDecrement()

◆ PostIncrement()

◆ PreDecrement()

◆ PreIncrement()

◆ ReadComma()

◆ ReadIdentifier()

◆ ReadLeftBrace()

◆ ReadLeftBracket()

◆ ReadLeftParenthesis()

◆ ReadPeriod()

◆ ReadRightBrace()

◆ ReadRightBracket()

◆ ReadRightParenthesis()

◆ ReadSemicolon()

◆ ReadToken()

◆ Relation()

◆ RelationalOpcode()

◆ RelationalOperator()

◆ ResolveForwardFunctionDeclarations()

◆ Return()

◆ RoutineCall()

◆ Run()

◆ ShiftLeft()

◆ ShiftRight()

◆ Statement()