I'm making a scripting language parser and it's shaping up well but it takes is about 30ms to do 30 or so odd/even checks. Profiler
Profiler tells me that it's taking most of the time in the InvokeOperator.OperateInvokeOperator.Operate function but that doesn't tell me a lot because the Operate call the Run method on the CodeBlockCodeBlock which in turn again calls the Operate call and makes it very hard to actually determine what's taking as long.
I don't know if you guys do full project reviews like this but I would appreciate it a lot.
Here's the Github repo https://github.com/LukaHorvat/KentoGithub repo
Here are the most important bits of the code:
Stack<Token> solvingStack = new Stack<Token>();
for ( int i = 0 ; i < value.Count ; ++i )
{
if ( value[ i ] is Operator )
{
Operator op = (Operator)value[ i ];
if ( op.Type == OperatorType.PrefixUnary || op.Type == OperatorType.SufixUnary )
{
op.Operate( ( solvingStack.Pop() as Value ), new NoValue() );
} else
{
Value second = (Value)solvingStack.Pop();
Value result = op.Operate( ( solvingStack.Pop() as Value ), second );
solvingStack.Push( result );
}
} else
{
solvingStack.Push( value[ i ] );
}
}
Compiler.ExitScope();
if ( solvingStack.Count == 0 ) return new NoValue();
else return (Value)solvingStack.Peek();
It's how the code is parsed after the infix expression is turned into RPN.
A token can be an operator or a value and a value can be a literal, identifier, codeblock..codeblock.
A
A somewhat special case is a function because it's not parsed to RPN directly but only the code inside of it is. Then is there's an invoke operator, it takes the array of arguments that was provided and the function before it and runs the function (which inherits from CodeBlockCodeBlock, so it also runs the same thing that is shown here).
What each operator does on different types of values is determined by the operator itself in the Operators.cs file.
