ScriptStack.Compiler.Parser Class Reference

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

Classes
struct	Variable
struct	FunctionDescriptor
struct	LoopControl
class	AccessSegment

Public Member Functions
string	ToLiteral (string input)
	Parser (Script script, List< Token > tokenStream)
Executable	Parse ()
	Parse the token stream into an executable.

Private Member Functions
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	ReadQualifiedIdentifier ()
	Read a dotted (qualified) identifier like: std.print or ns.io.print.
string	ExpectIdentifier ()
	Read an expected (previously declared) identifier.
void	VariableDeclaration ()
	Shared or local variable declaration.
void	LocalVariableDeclaration ()
void	Run ()
Variable	RoutineCall ()
Variable	Pointer ()
	Array access.
Variable	Member ()
	Member access.
Variable	AccessChain ()
	Mixed access chain parser.
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	BitwiseAnd ()
	Bitwise AND '&'.
Variable	BitwiseXor ()
	Bitwise XOR '^'.
Variable	BitwiseOr ()
	Bitwise OR '|'.
Variable	And ()
	Conjunction.
Variable	Or ()
	Disjunction (not exclusive).
Variable	VariableAssignment ()
Variable	AccessChainAssignment ()
	Mixed access chain assignment.
Variable	ArrayAssignment ()
Variable	MemberAssignment ()
Variable	Assignment ()
	An assignment can be a variable assignment, an array assignment or a member assignment.
bool	IsAccessChainAssignment ()
	Detect whether the upcoming tokens form an assignment expression.
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 Attributes
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

Detailed Description

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

Definition at line 21 of file Parser.cs.

Constructor & Destructor Documentation

Parser()

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

Definition at line 3336 of file Parser.cs.

        {
            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;
        }

References debugMode, derivation, executable, forwardDeclarations, functionFrameIndex, localVariables, loopControl, nextToken, script, tokenStream, and variables.

Member Function Documentation

AccessChain()

Variable ScriptStack.Compiler.Parser.AccessChain ( )

private

Mixed access chain parser.

Supports combinations of member and index access in arbitrary order, e.g.

obj.pets[0].name
pets[0].name
obj.map["x"].y[1]

The implementation lowers each postfix operation into a MOV into a temporary variable, so the runtime only needs to support OperandType.Member and OperandType.Pointer.

Definition at line 841 of file Parser.cs.

        {
 
            string identifier = ReadIdentifier();
 
            // We only get here if the next token is '[' or '.'
            string tmp = null;
 
            while (true)
            {
 
                if (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;
 
                    continue;
 
                }
 
                if (LookAhead().Type == TokenType.Period)
                {
 
                    ReadPeriod();
 
                    string member = ReadIdentifier();
 
                    // Method call on CLR object: obj.Member(...)
                    // Lowered into: PUSH args..., MIV obj.Member, <argc>, POP tmp
                    if (LookAhead().Type == TokenType.LeftParen)
                    {
 
                        ReadLeftParenthesis();
 
                        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;
 
                                ReadComma();
                            }
                        }
 
                        ReadRightParenthesis();
 
                        // invoke member
                        executable.InstructionsInternal.Add(
                            new Instruction(OpCode.MIV,
                                Operand.MemberVariable(identifier, member),
                                Operand.Literal(parameterCount)));
 
                        tmp = AllocateTemporaryVariable();
                        executable.InstructionsInternal.Add(new Instruction(OpCode.POP, Operand.Variable(tmp)));
 
                        identifier = tmp;
                        continue;
 
                    }
 
                    tmp = AllocateTemporaryVariable();
 
                    executable.InstructionsInternal.Add(
                        new Instruction(OpCode.MOV,
                            Operand.Variable(tmp),
                            Operand.MemberVariable(identifier, member)));
 
                    identifier = tmp;
 
                    continue;
 
                }
 
                break;
 
            }
 
            return new Variable(identifier, Scope.Local, null);
 
        }

References AllocateTemporaryVariable(), ScriptStack.Runtime.Operand.CreatePointer(), executable, Expression(), ScriptStack.Runtime.Operand.Literal(), LookAhead(), ScriptStack.Runtime.Operand.MemberVariable(), ScriptStack.Compiler.Parser.Variable.name, ReadComma(), ReadIdentifier(), ReadLeftBracket(), ReadLeftParenthesis(), ReadPeriod(), ReadRightBracket(), ReadRightParenthesis(), ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by Atom().

AccessChainAssignment()

Variable ScriptStack.Compiler.Parser.AccessChainAssignment ( )

private

Mixed access chain assignment.

Supports combinations of member and index access in arbitrary order on the LHS, e.g.

obj.pets[0].name = "Bello";
pets[0].name += "!";
obj.ints[0] = 123;
obj.map["x"].y[1] = 7;

The chain is lowered into temporary MOVs for intermediate steps; the last step becomes the actual assignment target (Variable/Member/Pointer).

Definition at line 2022 of file Parser.cs.

        {
 
            string identifier = ExpectIdentifier();
 
            List<Instruction> listInstructions = executable.InstructionsInternal;
 
            // Parse postfix chain (.) and ([]) until we hit an assignment operator.
            List<AccessSegment> segments = new List<AccessSegment>();
 
            while (true)
            {
                if (LookAhead().Type == TokenType.Period)
                {
                    ReadPeriod();
                    segments.Add(AccessSegment.Member(ReadIdentifier()));
                    continue;
                }
 
                if (LookAhead().Type == TokenType.LeftBracket)
                {
                    ReadLeftBracket();
                    Variable idx = Expression();
                    ReadRightBracket();
                    segments.Add(AccessSegment.Index(idx.name));
                    continue;
                }
 
                break;
            }
 
            Token tok = ReadToken();
 
            if (!AssignmentOperator(tok.Type))
                throw new ParserException("Ein Zuweisungsoperator wurde erwartet.", tok);
 
            Variable expression = Expression();
 
            // Lower intermediate access steps into temporaries.
            string current = identifier;
 
            for (int i = 0; i < segments.Count - 1; i++)
            {
                string tmp = AllocateTemporaryVariable();
                var seg = segments[i];
 
                Operand rhs = seg.IsMember
                    ? Operand.MemberVariable(current, seg.MemberName)
                    : Operand.CreatePointer(current, seg.IndexVar);
 
                listInstructions.Add(new Instruction(OpCode.MOV, Operand.Variable(tmp), rhs));
                current = tmp;
            }
 
            // Final destination operand (last segment) or plain variable.
            Operand dest;
 
            if (segments.Count == 0)
            {
                dest = Operand.Variable(current);
            }
            else
            {
                var last = segments[segments.Count - 1];
                dest = last.IsMember
                    ? Operand.MemberVariable(current, last.MemberName)
                    : Operand.CreatePointer(current, last.IndexVar);
            }
 
            listInstructions.Add(new Instruction(AssignmentOpcode(tok.Type), dest, Operand.Variable(expression.name)));
 
            // Return value of assignment expression
            string tmpIdentifier = AllocateTemporaryVariable();
            listInstructions.Add(new Instruction(OpCode.MOV, Operand.Variable(tmpIdentifier), dest));
 
            return new Variable(tmpIdentifier, Scope.Local, expression.derivatedType);
 
        }

References AllocateTemporaryVariable(), AssignmentOpcode(), AssignmentOperator(), ScriptStack.Runtime.Operand.CreatePointer(), ScriptStack.Compiler.Parser.Variable.derivatedType, executable, ExpectIdentifier(), Expression(), ScriptStack.Compiler.Parser.AccessSegment.Index(), LookAhead(), ScriptStack.Compiler.Parser.AccessSegment.Member(), ScriptStack.Runtime.Operand.MemberVariable(), ScriptStack.Compiler.Parser.Variable.name, ReadIdentifier(), ReadLeftBracket(), ReadPeriod(), ReadRightBracket(), ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by Assignment().

AllocateFunctionFrame()

void ScriptStack.Compiler.Parser.AllocateFunctionFrame ( )

private

Increase the function frame index.

Definition at line 321 of file Parser.cs.

        {
 
            functionFrameIndex++;
 
        }

References functionFrameIndex.

Referenced by Statement().

AllocateTemporaryVariable()

string ScriptStack.Compiler.Parser.AllocateTemporaryVariable ( )

private

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

Returns

Todo

performance?

Definition at line 333 of file Parser.cs.

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

References functionFrameIndex, localVariables, and variables.

Referenced by AccessChain(), AccessChainAssignment(), ArrayAssignment(), Atom(), BraceArray(), BracketArray(), Factor(), For(), ForEach(), FunctionCall(), Member(), MemberAssignment(), Pointer(), PostDecrement(), PostIncrement(), RoutineCall(), Switch(), and VariableAssignment().

AllocateVariable()

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

private

Allocate a local variable.

Parameters

identifier

Definition at line 303 of file Parser.cs.

        {
 
            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)));
 
        }

References executable, localVariables, ScriptStack.Runtime.Operand.Variable(), and variables.

Referenced by FunctionDeclaration(), and LocalVariableDeclaration().

And()

Variable ScriptStack.Compiler.Parser.And ( )

private

Conjunction.

Check for proposition (a signed atom)

Returns

Definition at line 1901 of file Parser.cs.

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

References BitwiseOr(), Derivate(), ScriptStack.Compiler.Parser.Variable.derivatedType, executable, ScriptStack.Compiler.Parser.Variable.name, ReadToken(), ScriptStack.Compiler.Token.Type, UndoToken(), and ScriptStack.Runtime.Operand.Variable().

Referenced by 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

Returns

Definition at line 1669 of file Parser.cs.

        {
 
            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;
 
                }
 
            }
 
        }

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

Referenced by Relation().

ArrayAssignment()

Variable ScriptStack.Compiler.Parser.ArrayAssignment ( )

private

Returns

Definition at line 2105 of file Parser.cs.

        {
 
            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);
 
        }

References AllocateTemporaryVariable(), AssignmentOpcode(), AssignmentOperator(), ScriptStack.Runtime.Operand.CreatePointer(), ScriptStack.Compiler.Parser.Variable.derivatedType, executable, ExpectIdentifier(), Expression(), LookAhead(), ScriptStack.Compiler.Parser.Variable.name, ReadLeftBracket(), ReadRightBracket(), ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Assignment()

Variable ScriptStack.Compiler.Parser.Assignment ( )

private

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

Returns

Definition at line 2218 of file Parser.cs.

        {
            // Unified assignment parser (supports Variable, Pointer, Member and mixed chains)
            return AccessChainAssignment();
        }

References AccessChainAssignment().

Referenced by Expression(), For(), and LocalVariableDeclaration().

AssignmentOpcode()

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

private

Parameters

tokenType

Returns

Definition at line 179 of file Parser.cs.

        {
 
            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.");
 
            }
 
        }

Referenced by AccessChainAssignment(), ArrayAssignment(), MemberAssignment(), and VariableAssignment().

AssignmentOperator()

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

private

Parameters

tokenType

Returns

Definition at line 149 of file Parser.cs.

        {
 
            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;
 
            }
 
        }

Referenced by AccessChainAssignment(), ArrayAssignment(), IsAccessChainAssignment(), IsMember(), IsPointer(), MemberAssignment(), and VariableAssignment().

Atom()

Variable ScriptStack.Compiler.Parser.Atom ( )

private

The smallest unit.

Returns

Definition at line 1222 of file Parser.cs.

        {
 
            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:
                case TokenType.Double:
                case TokenType.Decimal:
 
                    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:
 
                            // Support mixed access chains like obj.pets[0].name
                            // by parsing consecutive member (.) and index ([...]) postfixes.
                            UndoToken();
 
                            return AccessChain();
 
                        case TokenType.Period:
 
                            // Ambiguity: "std.print()" could be either a member-call on an object "std"
                            // or a qualified routine name.
                            //
                            // Rule: If the dotted name is followed by '(' AND the manager has a registered
                            // routine with that qualified name, treat it as a routine/function call.
                            // Otherwise parse it as an access chain (supports obj.method(...)).
                            {
 
                                int i = nextToken;
                                string qualified = identifier;
                                bool hasDot = false;
 
                                while (i < tokenStream.Count && tokenStream[i].Type == TokenType.Period)
                                {
 
                                    if (i + 1 >= tokenStream.Count || tokenStream[i + 1].Type != TokenType.Identifier)
                                        break;
 
                                    hasDot = true;
                                    qualified += "." + tokenStream[i + 1].Lexeme.ToString();
                                    i += 2;
 
                                }
 
                                bool looksLikeQualifiedCall = hasDot && i < tokenStream.Count && tokenStream[i].Type == TokenType.LeftParen;
 
                                if (looksLikeQualifiedCall && executable.Script.Manager.IsRegistered(qualified))
                                {
                                    UndoToken();
                                    return FunctionCall();
                                }
 
                                UndoToken();
                                return AccessChain();
 
                            }
 
                        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);
 
            }
 
        }

References AccessChain(), AllocateTemporaryVariable(), Atom(), executable, ExpectIdentifier(), Expression(), FunctionCall(), ScriptStack.Compiler.Token.Lexeme, Literal(), ScriptStack.Runtime.Operand.Literal(), LookAhead(), ScriptStack.Compiler.Parser.Variable.name, nextToken, PostDecrement(), PostIncrement(), PreDecrement(), PreIncrement(), ReadRightParenthesis(), ReadToken(), ShiftLeft(), ShiftRight(), tokenStream, ScriptStack.Compiler.Token.Type, UndoToken(), ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by Atom(), and Factor().

BinaryAnd()

Variable ScriptStack.Compiler.Parser.BinaryAnd ( )

private

Returns

Definition at line 1078 of file Parser.cs.

        {
 
            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;
 
        }

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

BinaryNot()

Variable ScriptStack.Compiler.Parser.BinaryNot ( )

private

Returns

Definition at line 1144 of file Parser.cs.

        {
 
            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;
 
        }

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

BinaryNotAssign()

Variable ScriptStack.Compiler.Parser.BinaryNotAssign ( )

private

Returns

Definition at line 1122 of file Parser.cs.

        {
 
            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;
 
        }

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

BinaryOr()

Variable ScriptStack.Compiler.Parser.BinaryOr ( )

private

Returns

Definition at line 1100 of file Parser.cs.

        {
 
            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;
 
        }

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

BitwiseAnd()

Variable ScriptStack.Compiler.Parser.BitwiseAnd ( )

private

Bitwise AND '&'.

Precedence (high -> low): ! (logical NOT) & ^ | && ||

This mirrors common C-like precedence and keeps bitwise ops above logical ops.

Definition at line 1792 of file Parser.cs.

        {
 
            List<Instruction> instructions = executable.InstructionsInternal;
 
            Variable first = Not();
 
            while (true)
            {
 
                Token token = ReadToken();
 
                if (token.Type == TokenType.BinaryAnd)
                {
 
                    Variable second = Not();
 
                    instructions.Add(new Instruction(OpCode.ANDB, Operand.Variable(first.name), Operand.Variable(second.name)));
 
                    // Bitwise ops currently work on int in the runtime
                    first.derivatedType = typeof(int);
 
                    continue;
 
                }
 
                UndoToken();
                return first;
 
            }
 
        }

References executable, ScriptStack.Compiler.Parser.Variable.name, Not(), ReadToken(), ScriptStack.Compiler.Token.Type, UndoToken(), and ScriptStack.Runtime.Operand.Variable().

Referenced by BitwiseXor().

BitwiseOr()

Variable ScriptStack.Compiler.Parser.BitwiseOr ( )

private

Bitwise OR '|'.

Definition at line 1863 of file Parser.cs.

        {
 
            List<Instruction> instructions = executable.InstructionsInternal;
 
            Variable first = BitwiseXor();
 
            while (true)
            {
 
                Token token = ReadToken();
 
                if (token.Type == TokenType.BinaryOr)
                {
 
                    Variable second = BitwiseXor();
 
                    instructions.Add(new Instruction(OpCode.ORB, Operand.Variable(first.name), Operand.Variable(second.name)));
 
                    first.derivatedType = typeof(int);
 
                    continue;
 
                }
 
                UndoToken();
                return first;
 
            }
 
        }

References BitwiseXor(), executable, ScriptStack.Compiler.Parser.Variable.name, ReadToken(), ScriptStack.Compiler.Token.Type, UndoToken(), and ScriptStack.Runtime.Operand.Variable().

Referenced by And().

BitwiseXor()

Variable ScriptStack.Compiler.Parser.BitwiseXor ( )

private

Bitwise XOR '^'.

Definition at line 1828 of file Parser.cs.

        {
 
            List<Instruction> instructions = executable.InstructionsInternal;
 
            Variable first = BitwiseAnd();
 
            while (true)
            {
 
                Token token = ReadToken();
 
                if (token.Type == TokenType.Xor)
                {
 
                    Variable second = BitwiseAnd();
 
                    instructions.Add(new Instruction(OpCode.XOR, Operand.Variable(first.name), Operand.Variable(second.name)));
 
                    first.derivatedType = typeof(int);
 
                    continue;
 
                }
 
                UndoToken();
                return first;
 
            }
 
        }

References BitwiseAnd(), executable, ScriptStack.Compiler.Parser.Variable.name, ReadToken(), ScriptStack.Compiler.Token.Type, UndoToken(), and ScriptStack.Runtime.Operand.Variable().

Referenced by BitwiseOr().

BraceArray()

Variable ScriptStack.Compiler.Parser.BraceArray ( )

private

An array enclosed in braces.

Returns

Definition at line 1414 of file Parser.cs.

        {
 
            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));
 
        }

References AllocateTemporaryVariable(), ScriptStack.Runtime.Operand.CreatePointer(), executable, Expression(), LookAhead(), ScriptStack.Runtime.Operand.MemberVariable(), ScriptStack.Compiler.Parser.Variable.name, ReadComma(), ReadLeftBrace(), ReadRightBrace(), ReadSemicolon(), ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by Factor().

BracketArray()

Variable ScriptStack.Compiler.Parser.BracketArray ( )

private

An array enclosed in brackets.

Returns

Definition at line 1494 of file Parser.cs.

        {
 
            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));
 
        }

References AllocateTemporaryVariable(), ScriptStack.Runtime.Operand.CreatePointer(), executable, Expression(), LookAhead(), ScriptStack.Runtime.Operand.MemberVariable(), ScriptStack.Compiler.Parser.Variable.name, ReadComma(), ReadLeftBracket(), ReadRightBracket(), ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by Factor().

Break()

void ScriptStack.Compiler.Parser.Break ( )

private

Definition at line 2664 of file Parser.cs.

        {
 
            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)));
 
        }

References ScriptStack.Runtime.Operand.AllocateInstructionPointer(), executable, loopControl, ReadSemicolon(), ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by Statement().

Continue()

void ScriptStack.Compiler.Parser.Continue ( )

private

Definition at line 2686 of file Parser.cs.

        {
 
            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)));
 
        }

References ScriptStack.Runtime.Operand.AllocateInstructionPointer(), executable, loopControl, ReadSemicolon(), ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by Statement().

Derivate()

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

private

Get the resulting type of two computed types.

Parameters

token
first
second

Returns

Definition at line 292 of file Parser.cs.

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

References derivation.

Referenced by And(), Arithmetic(), Or(), Relation(), and Term().

ExpectIdentifier()

string ScriptStack.Compiler.Parser.ExpectIdentifier ( )

private

Read an expected (previously declared) identifier.

Returns

Definition at line 555 of file Parser.cs.

        {
 
            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;
 
        }

References ScriptStack.Compiler.Token.Lexeme, localVariables, ReadToken(), ScriptStack.Compiler.Token.Type, and variables.

Referenced by AccessChainAssignment(), ArrayAssignment(), Atom(), BinaryAnd(), BinaryNotAssign(), BinaryOr(), ForEach(), MemberAssignment(), Notify(), PostDecrement(), PostIncrement(), PreDecrement(), PreIncrement(), ShiftLeft(), ShiftRight(), Switch(), VariableAssignment(), Wait(), and Xor().

Expression()

Variable ScriptStack.Compiler.Parser.Expression ( )

private

An expression is an assignment or a disjunction.

Returns

Definition at line 2371 of file Parser.cs.

        {
 
            if (IsAccessChainAssignment())
                return Assignment();
 
            else
                return Or();
 
        }

References Assignment(), IsAccessChainAssignment(), and Or().

Referenced by AccessChain(), AccessChainAssignment(), ArrayAssignment(), Atom(), BraceArray(), BracketArray(), For(), ForEach(), FunctionCall(), If(), IsAccessChainAssignment(), IsPointer(), LockedStatementList(), MemberAssignment(), Not(), Pointer(), Return(), RoutineCall(), Statement(), Switch(), VariableAssignment(), and While().

Factor()

Variable ScriptStack.Compiler.Parser.Factor ( )

private

Atom | Array.

Returns

Definition at line 1564 of file Parser.cs.

        {
 
 
            if (LookAhead().Type == TokenType.LeftBrace)
                return BraceArray();
 
            // test
            if (LookAhead().Type == TokenType.LeftBracket)
                return BracketArray();
 
            // unary bitwise NOT: "~x"
            if (LookAhead().Type == TokenType.BinaryNot)
            {
                ReadToken(); // "~"
 
                // binds tight and is right-associative: "~~x" etc.
                Variable right = Factor();
 
                string tmp = AllocateTemporaryVariable();
 
                executable.InstructionsInternal.Add(new Instruction(
                    OpCode.NOTB,
                    Operand.Variable(tmp),
                    Operand.Variable(right.name)
                ));
 
                // type: same as right, but practically int for bitwise
                Variable result = new Variable(tmp, Scope.Local, typeof(int));
                result.derivatedType = typeof(int);
 
                return result;
            }
 
            Variable variable = Atom();
 
            return variable;
 
        }

References AllocateTemporaryVariable(), Atom(), BraceArray(), BracketArray(), executable, Factor(), LookAhead(), ScriptStack.Compiler.Parser.Variable.name, ReadToken(), ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by BinaryAnd(), BinaryNot(), BinaryNotAssign(), BinaryOr(), Factor(), ShiftLeft(), ShiftRight(), Term(), and Xor().

For()

void ScriptStack.Compiler.Parser.For ( )

private

Definition at line 2472 of file Parser.cs.

        {
 
            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.JZ, 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);
 
        }

References ScriptStack.Runtime.Operand.AllocateInstructionPointer(), AllocateTemporaryVariable(), Assignment(), ScriptStack.Compiler.Parser.Variable.derivatedType, executable, Expression(), ScriptStack.Runtime.Operand.Literal(), LocalVariableDeclaration(), LookAhead(), loopControl, ScriptStack.Compiler.Parser.Variable.name, ReadLeftParenthesis(), ReadRightParenthesis(), ReadSemicolon(), ReadToken(), StatementList(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by Statement().

ForEach()

void ScriptStack.Compiler.Parser.ForEach ( )

private

Definition at line 2579 of file Parser.cs.

        {
 
            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)
                && array.derivatedType != typeof(string)
                && !typeof(System.Collections.IEnumerable).IsAssignableFrom(array.derivatedType))
                throw new ParserException("In ForEach Loops wird ein iterierbarer Ausdruck erwartet (Array/List/String/IEnumerable).", 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.JNZ, 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);
 
        }

References ScriptStack.Runtime.Operand.AllocateInstructionPointer(), AllocateTemporaryVariable(), ScriptStack.Runtime.Operand.CreatePointer(), ScriptStack.Compiler.Parser.Variable.derivatedType, executable, ExpectIdentifier(), Expression(), ScriptStack.Runtime.Operand.Literal(), loopControl, ScriptStack.Compiler.Parser.Variable.name, ReadLeftParenthesis(), ReadRightParenthesis(), ReadToken(), StatementList(), ScriptStack.Compiler.Token.Type, and ScriptStack.Runtime.Operand.Variable().

Referenced by Statement().

FreeFunctionFrame()

void ScriptStack.Compiler.Parser.FreeFunctionFrame ( )

private

Decrease the function frame index.

Definition at line 361 of file Parser.cs.

        {
 
            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;
 
        }

References functionFrameIndex, and localVariables.

Referenced by Statement().

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.

Returns

Definition at line 3034 of file Parser.cs.

        {
 
            // We must be able to look ahead without losing how many tokens we consumed.
            // For qualified routine names like "std.print(...)" we consume multiple tokens.
            int start = nextToken;
 
            string functionName = ReadQualifiedIdentifier();
 
            nextToken = start;
 
            if (executable.Script.Manager.IsRegistered(functionName))
                return RoutineCall();
 
            return FunctionCall(false);
 
        }

References executable, FunctionCall(), nextToken, ReadQualifiedIdentifier(), and RoutineCall().

Referenced by Atom(), FunctionCall(), and 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!

Todo

translate routines to msil?

Parameters

background

Returns

Definition at line 2922 of file Parser.cs.

        {
 
            string name = ReadQualifiedIdentifier();
 
            // 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;
 
        }

References ScriptStack.Runtime.Operand.AllocateFunctionPointer(), AllocateTemporaryVariable(), executable, Expression(), forwardDeclarations, LookAhead(), ScriptStack.Compiler.Parser.Variable.name, ReadComma(), ReadLeftParenthesis(), ReadQualifiedIdentifier(), ReadRightParenthesis(), ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.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.

Definition at line 2832 of file Parser.cs.

        {
 
            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();
 
        }

References AllocateVariable(), executable, ScriptStack.Compiler.Function, InsertDebugInfo(), ScriptStack.Compiler.Token.Lexeme, ScriptStack.Runtime.Operand.Literal(), localVariables, LookAhead(), ReadComma(), ReadIdentifier(), ReadLeftParenthesis(), ReadRightParenthesis(), ReadToken(), StatementList(), ScriptStack.Compiler.Token.Type, and ScriptStack.Runtime.Operand.Variable().

Referenced by ParseScript().

If()

void ScriptStack.Compiler.Parser.If ( )

private

Definition at line 2385 of file Parser.cs.

        {
 
            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.JZ, 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);
 
        }

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

Referenced by Statement().

InsertDebugInfo()

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

private

Definition at line 497 of file Parser.cs.

        {
 
            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)));
 
        }

References debugMode, executable, ScriptStack.Compiler.Token.Line, ScriptStack.Runtime.Operand.Literal(), and ScriptStack.Compiler.Token.Text.

Referenced by FunctionDeclaration(), Statement(), Switch(), and VariableDeclaration().

IsAccessChainAssignment()

bool ScriptStack.Compiler.Parser.IsAccessChainAssignment ( )

private

Detect whether the upcoming tokens form an assignment expression.

Supports mixed access chains on the LHS ('.' and '[]' in arbitrary order).

Definition at line 2229 of file Parser.cs.

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

References AssignmentOperator(), executable, Expression(), LookAhead(), ReadIdentifier(), ReadLeftBracket(), ReadPeriod(), ReadRightBracket(), ReadToken(), ScriptStack.Compiler.Token.Type, and UndoToken().

Referenced by Expression().

IsMember()

bool ScriptStack.Compiler.Parser.IsMember ( )

private

Returns

Definition at line 2329 of file Parser.cs.

        {
 
            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);
 
        }

References AssignmentOperator(), LookAhead(), ReadIdentifier(), ReadPeriod(), ReadToken(), ScriptStack.Compiler.Token.Type, and UndoToken().

IsPointer()

bool ScriptStack.Compiler.Parser.IsPointer ( )

private

Returns

Definition at line 2293 of file Parser.cs.

        {
 
            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);
 
        }

References AssignmentOperator(), executable, Expression(), LookAhead(), ReadIdentifier(), ReadLeftBracket(), ReadRightBracket(), ReadToken(), ScriptStack.Compiler.Token.Type, and UndoToken().

Literal()

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

private

Get the literal type of a token.

Parameters

tokenType

Returns

Todo

float <> double

Definition at line 258 of file Parser.cs.

        {
 
            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);
                case TokenType.Double:
                    return typeof(double);
                case TokenType.Decimal:
                    return typeof(decimal);
                default:
                    throw new ParserException( "Der Token '" + tokenType.ToString() + "' kann keinem Literal zugeordnet werden.");
 
            }
 
        }

Referenced by Atom().

LocalVariableDeclaration()

void ScriptStack.Compiler.Parser.LocalVariableDeclaration ( )

private

Definition at line 625 of file Parser.cs.

        {
 
            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();
 
            }
 
        }

References AllocateVariable(), Assignment(), ReadIdentifier(), ReadToken(), ScriptStack.Compiler.Token.Type, and UndoToken().

Referenced by For(), and Statement().

LockedStatementList()

void ScriptStack.Compiler.Parser.LockedStatementList ( )

private

Definition at line 3172 of file Parser.cs.

        {
 
            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)));
 
        }

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

Referenced by Statement().

LookAhead() [1/2]

Token ScriptStack.Compiler.Parser.LookAhead ( )

private

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

Returns

Definition at line 106 of file Parser.cs.

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

References More(), nextToken, and tokenStream.

Referenced by AccessChain(), AccessChainAssignment(), ArrayAssignment(), Atom(), BraceArray(), BracketArray(), Factor(), For(), FunctionCall(), FunctionDeclaration(), If(), IsAccessChainAssignment(), IsMember(), IsPointer(), Member(), MemberAssignment(), Not(), ParseScript(), Pointer(), ReadQualifiedIdentifier(), Return(), RoutineCall(), Statement(), StatementList(), and Switch().

LookAhead() [2/2]

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

private

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

Parameters

i

Returns

Definition at line 121 of file Parser.cs.

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

References More(), nextToken, and tokenStream.

Member()

Variable ScriptStack.Compiler.Parser.Member ( )

private

Member access.

Returns

Definition at line 800 of file Parser.cs.

        {
 
            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);
 
        }

References AllocateTemporaryVariable(), executable, LookAhead(), ScriptStack.Runtime.Operand.MemberVariable(), ReadIdentifier(), ReadPeriod(), ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

MemberAssignment()

Variable ScriptStack.Compiler.Parser.MemberAssignment ( )

private

Returns

Definition at line 2161 of file Parser.cs.

        {
 
            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;
 
        }

References AllocateTemporaryVariable(), AssignmentOpcode(), AssignmentOperator(), ScriptStack.Compiler.Parser.Variable.derivatedType, executable, ExpectIdentifier(), Expression(), LookAhead(), ScriptStack.Runtime.Operand.MemberVariable(), ScriptStack.Compiler.Parser.Variable.name, ReadIdentifier(), ReadPeriod(), ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

More()

bool ScriptStack.Compiler.Parser.More ( )

private

Check if there are more tokens available.

Returns

Definition at line 83 of file Parser.cs.

        {
            return nextToken < tokenStream.Count;
        }

References nextToken, and tokenStream.

Referenced by LookAhead(), LookAhead(), ParseScript(), ReadQualifiedIdentifier(), and ReadToken().

Not()

Variable ScriptStack.Compiler.Parser.Not ( )

private

Proposition.

May be a signed atom or a relation

Returns

Definition at line 1752 of file Parser.cs.

        {
 
            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();
 
        }

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

Referenced by BitwiseAnd().

Notify()

void ScriptStack.Compiler.Parser.Notify ( )

private

Todo

Definition at line 3244 of file Parser.cs.

        {
 
            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)));
 
        }

References executable, ExpectIdentifier(), ScriptStack.Runtime.Operand.Literal(), ReadSemicolon(), ReadToken(), ScriptStack.Compiler.Token.Type, and ScriptStack.Runtime.Operand.Variable().

Referenced by Statement().

Or()

Variable ScriptStack.Compiler.Parser.Or ( )

private

Disjunction (not exclusive).

Check for conjunction

Returns

Definition at line 1939 of file Parser.cs.

        {
 
            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);
 
                    continue;
 
                }
 
                UndoToken();
                return first;
 
            }
 
        }

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

Referenced by Expression().

Parse()

Executable ScriptStack.Compiler.Parser.Parse

(

)

Parse the token stream into an executable.

Returns

Definition at line 3355 of file Parser.cs.

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

References executable, forwardDeclarations, functionFrameIndex, localVariables, loopControl, nextToken, ParseScript(), ResolveForwardFunctionDeclarations(), script, and variables.

Referenced by ScriptStack.Runtime.Script.Script(), and ScriptStack.Runtime.Script.Script().

ParseScript()

void ScriptStack.Compiler.Parser.ParseScript ( )

private

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

Todo

Definition at line 3265 of file Parser.cs.

        {
 
            while (More())
            {
 
                Token token = LookAhead();
 
                if (token.Type == TokenType.Shared || token.Type == TokenType.Var)
                    VariableDeclaration();
 
                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();
 
            }
 
        }

References FunctionDeclaration(), LookAhead(), More(), ScriptStack.Compiler.Token.Type, and VariableDeclaration().

Referenced by 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

Todo

rename this! its not a pointer

Returns

Definition at line 768 of file Parser.cs.

        {
 
            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);
 
        }

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

PostDecrement()

Variable ScriptStack.Compiler.Parser.PostDecrement ( )

private

Returns

Definition at line 1010 of file Parser.cs.

        {
 
            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);
 
        }

References AllocateTemporaryVariable(), executable, ExpectIdentifier(), ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by Atom().

PostIncrement()

Variable ScriptStack.Compiler.Parser.PostIncrement ( )

private

Returns

Definition at line 986 of file Parser.cs.

        {
 
            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);
 
        }

References AllocateTemporaryVariable(), executable, ExpectIdentifier(), ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by Atom().

PreDecrement()

Variable ScriptStack.Compiler.Parser.PreDecrement ( )

private

Returns

Definition at line 966 of file Parser.cs.

        {
 
            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);
 
        }

References executable, ExpectIdentifier(), ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by Atom().

PreIncrement()

Variable ScriptStack.Compiler.Parser.PreIncrement ( )

private

Returns

Definition at line 946 of file Parser.cs.

        {
 
            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);
 
        }

References executable, ExpectIdentifier(), ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

Referenced by Atom().

ReadComma()

void ScriptStack.Compiler.Parser.ReadComma ( )

private

Definition at line 396 of file Parser.cs.

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

References ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by AccessChain(), BraceArray(), BracketArray(), FunctionCall(), FunctionDeclaration(), and RoutineCall().

ReadIdentifier()

string ScriptStack.Compiler.Parser.ReadIdentifier ( )

private

Read a new (previously NOT declared) identifier.

Returns

Definition at line 515 of file Parser.cs.

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

References ScriptStack.Compiler.Token.Lexeme, ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by AccessChain(), AccessChainAssignment(), FunctionDeclaration(), IsAccessChainAssignment(), IsMember(), IsPointer(), LocalVariableDeclaration(), Member(), MemberAssignment(), Pointer(), ReadQualifiedIdentifier(), and VariableDeclaration().

ReadLeftBrace()

void ScriptStack.Compiler.Parser.ReadLeftBrace ( )

private

Definition at line 435 of file Parser.cs.

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

References ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by BraceArray(), and Switch().

ReadLeftBracket()

void ScriptStack.Compiler.Parser.ReadLeftBracket ( )

private

Definition at line 461 of file Parser.cs.

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

References ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by AccessChain(), AccessChainAssignment(), ArrayAssignment(), BracketArray(), IsAccessChainAssignment(), IsPointer(), and Pointer().

ReadLeftParenthesis()

void ScriptStack.Compiler.Parser.ReadLeftParenthesis ( )

private

Definition at line 409 of file Parser.cs.

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

References ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by AccessChain(), For(), ForEach(), FunctionCall(), FunctionDeclaration(), If(), RoutineCall(), Switch(), and While().

ReadPeriod()

void ScriptStack.Compiler.Parser.ReadPeriod ( )

private

Definition at line 487 of file Parser.cs.

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

References ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by AccessChain(), AccessChainAssignment(), IsAccessChainAssignment(), IsMember(), Member(), MemberAssignment(), and ReadQualifiedIdentifier().

ReadQualifiedIdentifier()

string ScriptStack.Compiler.Parser.ReadQualifiedIdentifier ( )

private

Read a dotted (qualified) identifier like: std.print or ns.io.print.

This is intentionally ONLY used for function/routine names. Member access on variables is parsed by AccessChain.

Definition at line 533 of file Parser.cs.

        {
 
            string id = ReadIdentifier();
 
            while (More() && LookAhead().Type == TokenType.Period)
            {
 
                ReadPeriod();
 
                id += "." + ReadIdentifier();
 
            }
 
            return id;
 
        }

References LookAhead(), More(), ReadIdentifier(), and ReadPeriod().

Referenced by FunctionCall(), FunctionCall(), and RoutineCall().

ReadRightBrace()

void ScriptStack.Compiler.Parser.ReadRightBrace ( )

private

Definition at line 448 of file Parser.cs.

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

References ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by BraceArray(), StatementList(), and Switch().

ReadRightBracket()

void ScriptStack.Compiler.Parser.ReadRightBracket ( )

private

Definition at line 474 of file Parser.cs.

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

References ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by AccessChain(), AccessChainAssignment(), ArrayAssignment(), BracketArray(), IsAccessChainAssignment(), IsPointer(), and Pointer().

ReadRightParenthesis()

void ScriptStack.Compiler.Parser.ReadRightParenthesis ( )

private

Definition at line 422 of file Parser.cs.

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

References ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by AccessChain(), Atom(), For(), ForEach(), FunctionCall(), FunctionDeclaration(), If(), RoutineCall(), Switch(), and While().

ReadSemicolon()

void ScriptStack.Compiler.Parser.ReadSemicolon ( )

private

Definition at line 383 of file Parser.cs.

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

References ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by BraceArray(), Break(), Continue(), For(), Notify(), Return(), Run(), Statement(), Wait(), and Yield().

ReadToken()

Token ScriptStack.Compiler.Parser.ReadToken ( )

private

Get the next available token.

Returns

Definition at line 92 of file Parser.cs.

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

References More(), nextToken, and tokenStream.

Referenced by AccessChainAssignment(), And(), Arithmetic(), ArrayAssignment(), Atom(), BinaryAnd(), BinaryNot(), BinaryNotAssign(), BinaryOr(), BitwiseAnd(), BitwiseOr(), BitwiseXor(), BraceArray(), BracketArray(), Break(), Continue(), ExpectIdentifier(), Factor(), For(), ForEach(), FunctionDeclaration(), If(), IsAccessChainAssignment(), IsMember(), IsPointer(), LocalVariableDeclaration(), LockedStatementList(), MemberAssignment(), Not(), Notify(), Or(), PostDecrement(), PostIncrement(), PreDecrement(), PreIncrement(), ReadComma(), ReadIdentifier(), ReadLeftBrace(), ReadLeftBracket(), ReadLeftParenthesis(), ReadPeriod(), ReadRightBrace(), ReadRightBracket(), ReadRightParenthesis(), ReadSemicolon(), Relation(), Return(), Run(), ShiftLeft(), ShiftRight(), Statement(), StatementList(), Switch(), Term(), VariableAssignment(), VariableDeclaration(), Wait(), While(), Xor(), and Yield().

Relation()

Variable ScriptStack.Compiler.Parser.Relation ( )

private

Returns

Definition at line 1720 of file Parser.cs.

        {
 
            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;
 
        }

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

Referenced by Not().

RelationalOpcode()

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

private

Parameters

tokenType

Returns

Definition at line 233 of file Parser.cs.

        {
 
            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.");
 
            }
 
        }

Referenced by Relation().

RelationalOperator()

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

private

Parameters

tokenType

Returns

Definition at line 207 of file Parser.cs.

        {
 
            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;
 
            }
 
        }

Referenced by Relation().

ResolveForwardFunctionDeclarations()

void ScriptStack.Compiler.Parser.ResolveForwardFunctionDeclarations ( )

private

Resolve unresolved, forward declared functions.

Definition at line 3301 of file Parser.cs.

        {
 
            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;
 
            }
 
        }

References executable, forwardDeclarations, and ScriptStack.Compiler.Parser.FunctionDescriptor.name.

Referenced by Parse().

Return()

void ScriptStack.Compiler.Parser.Return ( )

private

By default null is returned.

Definition at line 2807 of file Parser.cs.

        {
 
            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;
 
        }

References executable, Expression(), ScriptStack.Runtime.Operand.Literal(), LookAhead(), ReadSemicolon(), ReadToken(), ScriptStack.Compiler.Token.Type, and ScriptStack.Runtime.Operand.Variable().

Referenced by Statement().

RoutineCall()

Variable ScriptStack.Compiler.Parser.RoutineCall ( )

private

Todo

Run routines in background? bad for cloud

Returns

Definition at line 692 of file Parser.cs.

        {
 
            string identifier = ReadQualifiedIdentifier();
 
            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;
 
        }

References ScriptStack.Runtime.Operand.AllocateRoutinePointer(), AllocateTemporaryVariable(), ScriptStack.Runtime.Routine.Description(), executable, Expression(), LookAhead(), ScriptStack.Compiler.Parser.Variable.name, ScriptStack.Runtime.Routine.ParameterTypes, ReadComma(), ReadLeftParenthesis(), ReadQualifiedIdentifier(), ReadRightParenthesis(), ScriptStack.Manager.Routines, and ScriptStack.Runtime.Operand.Variable().

Referenced by FunctionCall().

Run()

void ScriptStack.Compiler.Parser.Run ( )

private

Definition at line 673 of file Parser.cs.

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

References FunctionCall(), ReadSemicolon(), ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by Statement().

ShiftLeft()

Variable ScriptStack.Compiler.Parser.ShiftLeft ( )

private

Returns

Definition at line 1034 of file Parser.cs.

        {
 
            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;
 
        }

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

Referenced by Atom().

ShiftRight()

Variable ScriptStack.Compiler.Parser.ShiftRight ( )

private

Returns

Definition at line 1056 of file Parser.cs.

        {
 
            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;
 
        }

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

Referenced by Atom().

Statement()

void ScriptStack.Compiler.Parser.Statement ( )

private

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

Definition at line 3055 of file Parser.cs.

        {
 
            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();
 
        }

References AllocateFunctionFrame(), Break(), Continue(), Expression(), For(), ForEach(), FreeFunctionFrame(), If(), InsertDebugInfo(), ScriptStack.Compiler.Token.Lexeme, LocalVariableDeclaration(), LockedStatementList(), LookAhead(), Notify(), ReadSemicolon(), ReadToken(), Return(), Run(), StatementList(), Switch(), ScriptStack.Compiler.Token.Type, Wait(), While(), and Yield().

Referenced by LockedStatementList(), StatementList(), and 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.

Definition at line 3147 of file Parser.cs.

        {
 
            // 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();
 
        }

References LookAhead(), ReadRightBrace(), ReadToken(), and Statement().

Referenced by For(), ForEach(), FunctionDeclaration(), If(), Statement(), and While().

Switch()

void ScriptStack.Compiler.Parser.Switch ( )

private

Definition at line 2708 of file Parser.cs.

        {
 
            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.JZ, 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);
 
        }

References ScriptStack.Runtime.Operand.AllocateInstructionPointer(), AllocateTemporaryVariable(), executable, ExpectIdentifier(), Expression(), InsertDebugInfo(), ScriptStack.Runtime.Operand.Literal(), LookAhead(), ScriptStack.Compiler.Parser.Variable.name, ReadLeftBrace(), ReadLeftParenthesis(), ReadRightBrace(), ReadRightParenthesis(), ReadToken(), Statement(), ScriptStack.Compiler.Token.Type, and ScriptStack.Runtime.Operand.Variable().

Referenced by Statement().

Term()

Variable ScriptStack.Compiler.Parser.Term ( )

private

Factor ( [*|/|%] Factor ).

Returns

Definition at line 1608 of file Parser.cs.

        {
 
            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;
 
                }
 
            }
 
        }

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

Referenced by Arithmetic().

ToLiteral()

string ScriptStack.Compiler.Parser.ToLiteral

(

string

input

)

Definition at line 1182 of file Parser.cs.

        {
            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.

Definition at line 134 of file Parser.cs.

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

References nextToken.

Referenced by And(), Arithmetic(), Atom(), BitwiseAnd(), BitwiseOr(), BitwiseXor(), IsAccessChainAssignment(), IsMember(), IsPointer(), LocalVariableDeclaration(), Or(), Relation(), and Term().

VariableAssignment()

Variable ScriptStack.Compiler.Parser.VariableAssignment ( )

private

Returns

Definition at line 1975 of file Parser.cs.

        {
 
            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);
 
        }

References AllocateTemporaryVariable(), AssignmentOpcode(), AssignmentOperator(), ScriptStack.Compiler.Parser.Variable.derivatedType, executable, ExpectIdentifier(), Expression(), ScriptStack.Compiler.Parser.Variable.name, ReadToken(), ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and ScriptStack.Runtime.Variable.

VariableDeclaration()

void ScriptStack.Compiler.Parser.VariableDeclaration ( )

private

Shared or local variable declaration.

Definition at line 575 of file Parser.cs.

        {
 
            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();
 
            }
 
        }

References executable, InsertDebugInfo(), ReadIdentifier(), ReadToken(), script, ScriptStack.Compiler.Token.Type, ScriptStack.Runtime.Operand.Variable(), and variables.

Referenced by ParseScript().

Wait()

void ScriptStack.Compiler.Parser.Wait ( )

private

Wait for a locked secion of code to be freed.

Todo

Definition at line 3212 of file Parser.cs.

        {
 
            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);
 
        }

References ScriptStack.Runtime.Operand.AllocateInstructionPointer(), executable, ExpectIdentifier(), ReadSemicolon(), ReadToken(), ScriptStack.Compiler.Token.Type, and ScriptStack.Runtime.Operand.Variable().

Referenced by Statement().

While()

void ScriptStack.Compiler.Parser.While ( )

private

Definition at line 2426 of file Parser.cs.

        {
 
            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.JZ, 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);
 
        }

References ScriptStack.Runtime.Operand.AllocateInstructionPointer(), ScriptStack.Compiler.Parser.Variable.derivatedType, executable, Expression(), loopControl, ScriptStack.Compiler.Parser.Variable.name, ReadLeftParenthesis(), ReadRightParenthesis(), ReadToken(), StatementList(), ScriptStack.Compiler.Token.Type, and ScriptStack.Runtime.Operand.Variable().

Referenced by Statement().

Xor()

Variable ScriptStack.Compiler.Parser.Xor ( )

private

Returns

Definition at line 1164 of file Parser.cs.

        {
 
            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;
 
        }

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

Yield()

void ScriptStack.Compiler.Parser.Yield ( )

private

Definition at line 3193 of file Parser.cs.

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

References executable, ReadSemicolon(), ReadToken(), and ScriptStack.Compiler.Token.Type.

Referenced by Statement().

Member Data Documentation

debugMode

bool ScriptStack.Compiler.Parser.debugMode

private

Definition at line 64 of file Parser.cs.

Referenced by InsertDebugInfo(), and Parser().

derivation

Derivation ScriptStack.Compiler.Parser.derivation

private

Definition at line 72 of file Parser.cs.

Referenced by Derivate(), and Parser().

executable

Executable ScriptStack.Compiler.Parser.executable

private

Definition at line 73 of file Parser.cs.

Referenced by AccessChain(), AccessChainAssignment(), AllocateVariable(), And(), Arithmetic(), ArrayAssignment(), Atom(), BinaryAnd(), BinaryNot(), BinaryNotAssign(), BinaryOr(), BitwiseAnd(), BitwiseOr(), BitwiseXor(), BraceArray(), BracketArray(), Break(), Continue(), Factor(), For(), ForEach(), FunctionCall(), FunctionCall(), FunctionDeclaration(), If(), InsertDebugInfo(), IsAccessChainAssignment(), IsPointer(), LockedStatementList(), Member(), MemberAssignment(), Not(), Notify(), Or(), Parse(), Parser(), Pointer(), PostDecrement(), PostIncrement(), PreDecrement(), PreIncrement(), Relation(), ResolveForwardFunctionDeclarations(), Return(), RoutineCall(), ShiftLeft(), ShiftRight(), Switch(), Term(), VariableAssignment(), VariableDeclaration(), Wait(), While(), Xor(), and Yield().

forwardDeclarations

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

private

Definition at line 70 of file Parser.cs.

Referenced by FunctionCall(), Parse(), Parser(), and ResolveForwardFunctionDeclarations().

functionFrameIndex

int ScriptStack.Compiler.Parser.functionFrameIndex

private

Definition at line 69 of file Parser.cs.

Referenced by AllocateFunctionFrame(), AllocateTemporaryVariable(), FreeFunctionFrame(), Parse(), and Parser().

localVariables

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

private

Definition at line 68 of file Parser.cs.

Referenced by AllocateTemporaryVariable(), AllocateVariable(), ExpectIdentifier(), FreeFunctionFrame(), FunctionDeclaration(), Parse(), and Parser().

loopControl

Stack<LoopControl> ScriptStack.Compiler.Parser.loopControl

private

Definition at line 71 of file Parser.cs.

Referenced by Break(), Continue(), For(), ForEach(), Parse(), Parser(), and While().

nextToken

int ScriptStack.Compiler.Parser.nextToken

private

Definition at line 66 of file Parser.cs.

Referenced by Atom(), FunctionCall(), LookAhead(), LookAhead(), More(), Parse(), Parser(), ReadToken(), and UndoToken().

script

Script ScriptStack.Compiler.Parser.script

private

Definition at line 63 of file Parser.cs.

Referenced by Parse(), Parser(), and VariableDeclaration().

tokenStream

List<Token> ScriptStack.Compiler.Parser.tokenStream

private

Definition at line 65 of file Parser.cs.

Referenced by Atom(), LookAhead(), LookAhead(), More(), Parser(), and ReadToken().

variables

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

private

Definition at line 67 of file Parser.cs.

Referenced by AllocateTemporaryVariable(), AllocateVariable(), ExpectIdentifier(), Parse(), Parser(), and VariableDeclaration().

---

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

• Src/Compiler/Parser.cs