public static PainCodeLine PrevLineWithLessDepth(
            this PainCodeLines Lines,
            PainCodeLine StartLine,
            Func <PainCodeLine, Boolean> Predicate)
        {
            Int32 depth = (StartLine == null ? 0 : StartLine.Depth);
            Int32 index = (StartLine == null ? 0 : Lines.IndexOf(StartLine));

            if (index < 0)
            {
                return(null);
            }

            for (var i = index - 1; i >= 0; i--)
            {
                PainCodeLine line = Lines[i];
                if (!line.IsLineEmpty && line.Depth < depth)
                {
                    if (Predicate == null || Predicate(line))
                    {
                        return(line);
                    }
                }
            }

            return(null);
        }
        public static PainCodeLine NextOnSameOrHigher(
            this PainCodeLines Lines,
            PainCodeLine StartLine)
        {
            Int32 depth = (StartLine == null ? 0 : StartLine.Depth);
            Int32 index = (StartLine == null ? 0 : Lines.IndexOf(StartLine));

            if (index < 0)
            {
                return(null);
            }

            for (var i = index + 1; i < Lines.Count; i++)
            {
                PainCodeLine line = Lines[i];
                if (!line.IsLineEmpty)
                {
                    if (line.Depth > depth)
                    {
                        return(line);
                    }
                    else if (line.Depth == depth)
                    {
                        return(line);
                    }
                }
            }

            return(null);
        }
        public static PainCodeLine NextOnSameOrLower(
            this PainCodeLines Lines,
            PainCodeLine StartLine,
            Func <PainCodeLine, Boolean> Predicate = null)
        {
            Int32 depth = (StartLine == null ? 0 : StartLine.Depth);
            Int32 index = (StartLine == null ? 0 : Lines.IndexOf(StartLine));

            if (index < 0)
            {
                return(null);
            }

            for (var i = index + 1; i < Lines.Count; i++)
            {
                PainCodeLine line = Lines[i];
                if (!line.IsLineEmpty && line.Depth <= depth)
                {
                    if (Predicate == null || Predicate(line))
                    {
                        return(line);
                    }
                }
            }

            return(null);
        }
Example #4
0
        private static Boolean?ExecuteCalculations(
            PainContext PainContext,
            PainState currentState,
            out Object Result)
        {
            Result = null;
            PainCodeLines lines       = currentState.GetCurrentLines();
            PainCodeLine  currentLine = currentState.GetCurrentLine();

            // wykonanie kalkulacji
            if (currentLine.ContainsAnyExpressions() &&
                currentLine.OperatorType != EOperatorType.ELSE)
            {
                if (PainContext.CurrentState.ExpressionContext == null)
                {
                    PainContext.CurrentState.ExpressionContext = new ExpressionContext(currentLine.ExpressionGroup);
                }

                if (PainContext.CurrentState.ExpressionContext != null &&
                    PainContext.CurrentState.ExpressionContext.IsFinished)
                {
                    Result = PainContext.CurrentState.ExpressionContext.Result;
                    PainContext.CurrentState.ExpressionContext = null;
                }
                else
                {
                    try
                    {
                        Boolean result = ExpressionRunner.NextStep(
                            PainContext);

                        return(result);
                    }
                    catch
                    {
                        throw;
                    }
                }
            }

            return(null);
        }
        public static PainCodeLine ExitParentIf(
            this PainCodeLines Lines,
            PainCodeLine StartLine)
        {
            Int32 depth = (StartLine == null ? 0 : StartLine.Depth);
            Int32 index = (StartLine == null ? 0 : Lines.IndexOf(StartLine));

            if (index < 0)
            {
                return(null);
            }

            PainCodeLine line = StartLine;

            while (true)
            {
                line = NextLine(
                    Lines,
                    line);

                if (line == null)
                {
                    break;
                }

                if (line.Depth < StartLine.Depth)
                {
                    return(line);
                }

                if (line.Depth == StartLine.Depth &&
                    line.OperatorType != EOperatorType.ELIF &&
                    line.OperatorType != EOperatorType.ELSE)
                {
                    return(line);
                }
            }

            return(null);
        }
Example #6
0
        private static Boolean?CheckIfFinishedOrEmptyLine(
            PainContext PainContext,
            PainState currentState)
        {
            if (currentState == null || PainContext.IsFinished)
            {
                PainContext.IsFinished = true;
                return(true);
            }

            PainCodeLines lines       = currentState.GetCurrentLines();
            PainCodeLine  currentLine = currentState.GetCurrentLine();

            if (currentLine == null)
            {
                return(ExitCurrentContext(
                           PainContext));
            }

            // jeśli linia jest pusta to przechodzimy do nastepnej
            if (currentLine.IsLineEmpty)
            {
                PainCodeLine nextLine = lines.NextLine(currentLine);
                if (nextLine == null)
                {
                    return(ExitCurrentContext(
                               PainContext));
                }
                else
                {
                    currentState.CurrentLineID = nextLine.ID;
                }
                return(true);
            }
            return(null);
        }
Example #7
0
        private static Boolean GotoCatch(
            PainContext PainContext,
            Exception exception)
        {
            while (true)
            {
                PainState currentState = PainContext.
                                         CurrentState;

                // reset dla kontekstu obliczeń, ponieważ przechodzimy do catch'a
                currentState.ExpressionContext = null;

                PainCodeLines lines       = currentState.GetCurrentLines();
                PainCodeLine  currentLine = currentState.GetCurrentLine();

                // poszukanie poprzedniego catch'a
                PainCodeLine prevCatch = lines.
                                         PrevLineWithLessDepth(currentLine, l => l.OperatorType == EOperatorType.CATCH);

                // poszukanie poprzedniego try'a
                PainCodeLine prevTry = lines.
                                       PrevLineWithLessDepth(currentLine, l => l.OperatorType == EOperatorType.TRY);

                if (prevTry == null)
                {
                    ExitCurrentContext(
                        PainContext);

                    if (PainContext.IsFinished)
                    {
                        break;
                    }
                }
                // jeśli znalazł try'a i nie jesteśmy w catch'u
                else if (prevTry.Depth < currentLine.Depth &&
                         (prevCatch == null || lines.IndexOf(prevCatch) < lines.IndexOf(prevTry)))
                {
                    PainCodeLine nextCatch = lines.NextOnSameOrLower(
                        prevTry,
                        i => i.OperatorType == EOperatorType.CATCH);

                    if (nextCatch != null)
                    {
                        ExpressionToken variableForException =
                            nextCatch.ExpressionGroup != null &&
                            nextCatch.ExpressionGroup.MainExpression != null &&
                            nextCatch.ExpressionGroup.MainExpression.Tokens != null &&
                            nextCatch.ExpressionGroup.MainExpression.Tokens.Count > 0 ?
                            nextCatch.
                            ExpressionGroup.
                            MainExpression.
                            Tokens.
                            FirstOrDefault(i => i.TokenType != TokenType.BRACKET_BEGIN) :
                            null;

                        currentState.CurrentLineID = nextCatch.ID;

                        if (variableForException != null && !String.IsNullOrEmpty(variableForException.TokenName))
                        {
                            currentState.Object[variableForException.TokenName] = exception;
                        }

                        break;
                    }
                    else
                    {
                        ExitCurrentContext(
                            PainContext);

                        if (PainContext.IsFinished)
                        {
                            break;
                        }
                    }
                }
                else
                {
                    ExitCurrentContext(
                        PainContext);

                    if (PainContext.IsFinished)
                    {
                        break;
                    }
                }
            }
            return(false);
        }
Example #8
0
        //////////////////////////////////////////////

        private static Boolean GotoNextLine(
            PainContext PainContext,
            PainState currentState,
            Object currentValue)
        {
            try
            {
                PainCodeLines lines       = currentState.GetCurrentLines();
                PainCodeLine  currentLine = currentState.GetCurrentLine();

                // jesli return to konczymy
                if (currentLine.OperatorType == EOperatorType.RETURN)
                {
                    return(ExitCurrentContext(
                               PainContext,
                               currentValue));
                }
                // throw błędu
                else if (currentLine.OperatorType == EOperatorType.THROW)
                {
                    if (currentValue is Exception)
                    {
                        throw (Exception)currentValue;
                    }
                    else
                    {
                        String message = UniConvert.ToString(currentValue ?? "");
                        throw String.IsNullOrEmpty(message) ? new Exception() : new Exception(message);
                    }

                    /*return ExitCurrentContext(
                     *  PainContext,
                     *  new Exception(message));*/
                }

                if (currentLine.OperatorType == EOperatorType.WHILE ||
                    currentLine.OperatorType == EOperatorType.IF ||
                    currentLine.OperatorType == EOperatorType.ELIF)
                {
                    Boolean conditionResult = currentValue.IfTrue();
                    if (conditionResult)
                    {
                        PainCodeLine nextLine = lines.NextOnSameOrHigher(currentLine);
                        if (nextLine != null)
                        {
                            currentState.CurrentLineID = nextLine.ID;
                        }
                        else
                        {
                            throw new NotImplementedException();
                        }
                    }
                    else
                    {
                        PainCodeLine nextLine = lines.NextOnSameOrLower(currentLine);
                        if (nextLine == null)
                        {
                            return(ExitCurrentContext(
                                       PainContext));
                        }
                        else
                        {
                            if (nextLine.Depth < currentLine.Depth)
                            {
                                while (
                                    nextLine != null &
                                    (nextLine.OperatorType == EOperatorType.ELSE ||
                                     nextLine.OperatorType == EOperatorType.ELIF /*||
                                                                                  * nextLine.OperatorType == EOperatorType.FINALLY*/))
                                {
                                    nextLine = lines.ExitParentIf(nextLine);

                                    if (nextLine == null)
                                    {
                                        break;
                                    }
                                }

                                if (nextLine == null)
                                {
                                    return(ExitCurrentContext(
                                               PainContext));
                                }

                                if (nextLine.Depth < currentLine.Depth)
                                {
                                    //PainCodeLine prevIf = lines.
                                    //    PrevLineWithLessDepth(currentLine, l => l.OperatorType == EOperatorType.IF || l.OperatorType == EOperatorType.ELIF);

                                    while (true)
                                    {
                                        PainCodeLine prevConditionLine = lines.
                                                                         PrevLineWithLessDepth(
                                            currentLine,
                                            l => l.OperatorType == EOperatorType.IF || l.OperatorType == EOperatorType.ELIF || l.OperatorType == EOperatorType.ELSE || l.OperatorType == EOperatorType.WHILE);

                                        if (prevConditionLine != null &&
                                            prevConditionLine.Depth >= nextLine.Depth &&
                                            prevConditionLine.OperatorType == EOperatorType.WHILE)
                                        {
                                            currentState.CurrentLineID = prevConditionLine.ID;
                                            break;
                                        }
                                        else if (prevConditionLine != null)
                                        {
                                            currentLine = prevConditionLine;
                                        }
                                        else
                                        {
                                            currentState.CurrentLineID = nextLine.ID;
                                            break;
                                        }
                                    }
                                }
                                else
                                {
                                    currentState.CurrentLineID = nextLine.ID;
                                }
                            }
                            else
                            {
                                currentState.CurrentLineID = nextLine.ID;
                            }
                        }
                    }
                }
                else if (
                    currentLine.OperatorType == EOperatorType.TRY ||
                    currentLine.OperatorType == EOperatorType.ELSE)
                {
                    PainCodeLine nextLine = lines.NextOnSameOrHigher(currentLine);
                    if (nextLine != null)
                    {
                        currentState.CurrentLineID = nextLine.ID;
                    }
                    else
                    {
                        throw new NotImplementedException();
                    }
                }
                else if (
                    (currentLine.OperatorType == EOperatorType.FINALLY))
                {
                    throw new NotImplementedException("FINALLY");
                }
                else if (
                    (currentLine.OperatorType == EOperatorType.CATCH))
                {
                    if (PainContext.Error != null)
                    {
                        PainContext.Error = null;
                        PainCodeLine nextLine = lines.NextOnSameOrHigher(currentLine);
                        if (nextLine != null)
                        {
                            currentState.CurrentLineID = nextLine.ID;
                        }
                        else
                        {
                            throw new NotImplementedException();
                        }
                    }
                    else
                    {
                        PainCodeLine nextLine = lines.NextOnSameOrLower(currentLine);
                        if (nextLine != null)
                        {
                            currentState.CurrentLineID = nextLine.ID;
                        }
                        else
                        {
                            return(ExitCurrentContext(
                                       PainContext));
                        }
                    }
                }
                else if (currentLine.OperatorType == EOperatorType.NONE)
                {
                    PainCodeLine nextLine = lines.NextLine(currentLine);
                    if (nextLine != null)
                    {
                        while (
                            nextLine != null &
                            (nextLine.OperatorType == EOperatorType.ELSE ||
                             nextLine.OperatorType == EOperatorType.ELIF /*||
                                                                          * nextLine.OperatorType == EOperatorType.FINALLY*/))
                        {
                            nextLine = lines.ExitParentIf(nextLine);

                            if (nextLine == null)
                            {
                                return(ExitCurrentContext(
                                           PainContext));
                            }
                        }

                        if (nextLine == null)
                        {
                            return(ExitCurrentContext(
                                       PainContext));
                        }

                        if (nextLine.Depth < currentLine.Depth)
                        {
                            //PainCodeLine prevIf = lines.
                            //    PrevLineWithLessDepth(currentLine, l => l.OperatorType == EOperatorType.IF || l.OperatorType == EOperatorType.ELIF);

                            while (true)
                            {
                                PainCodeLine prevConditionLine = lines.
                                                                 PrevLineWithLessDepth(
                                    currentLine,
                                    l => l.OperatorType == EOperatorType.IF || l.OperatorType == EOperatorType.ELIF || l.OperatorType == EOperatorType.ELSE || l.OperatorType == EOperatorType.WHILE);

                                if (prevConditionLine != null &&
                                    prevConditionLine.Depth >= nextLine.Depth &&
                                    prevConditionLine.OperatorType == EOperatorType.WHILE)
                                {
                                    currentState.CurrentLineID = prevConditionLine.ID;
                                    break;
                                }
                                else if (prevConditionLine != null)
                                {
                                    currentLine = prevConditionLine;
                                }
                                else
                                {
                                    currentState.CurrentLineID = nextLine.ID;
                                    break;
                                }
                            }
                        }
                        else
                        {
                            currentState.CurrentLineID = nextLine.ID;
                        }
                    }
                    // jeśli ostatnia linia i jesteśmy w while'u
                    else
                    {
                        //PainCodeLine prevIf = lines.
                        //    PrevLineWithLessDepth(currentLine, l => l.OperatorType == EOperatorType.IF || l.OperatorType == EOperatorType.ELIF);

                        while (true)
                        {
                            PainCodeLine prevConditionLine = lines.
                                                             PrevLineWithLessDepth(
                                currentLine,
                                l => l.OperatorType == EOperatorType.IF || l.OperatorType == EOperatorType.ELIF || l.OperatorType == EOperatorType.ELSE || l.OperatorType == EOperatorType.WHILE);

                            if (prevConditionLine != null &&
                                prevConditionLine.OperatorType == EOperatorType.WHILE)
                            {
                                currentState.CurrentLineID = prevConditionLine.ID;
                                break;
                            }
                            else if (prevConditionLine != null)
                            {
                                currentLine = prevConditionLine;
                            }
                            else
                            {
                                return(ExitCurrentContext(
                                           PainContext));
                            }
                        }
                    }
                }
                return(false);
            }
            catch
            {
                throw;
            }
        }
Example #9
0
        public PainProgram Compile(IList <Char> Code)
        {
            CodeLines lines = GetLines(Code);

            PainProgram        mainProgram = new PainProgram();
            List <PainProgram> methodStack = new List <PainProgram>();

            methodStack.Push(mainProgram);

            foreach (CodeLine line in lines)
            {
                Int32 currentDepth = -1;

                PainMethod method = null;
                method = GetMethodDefinition(line);
                if (method != null)
                {
                    currentDepth = method.Depth;
                }

                PainClass classDefinition = null;
                if (method == null)
                {
                    classDefinition = GetClassDefinition(line);
                    if (classDefinition != null)
                    {
                        currentDepth = classDefinition.Depth;
                    }
                }

                PainCodeLine codeLine = null;
                if (method == null && classDefinition == null)
                {
                    codeLine = GetCodeLine(line);
                    if (codeLine != null)
                    {
                        currentDepth = codeLine.Depth;
                    }
                }

                PainProgram currentMethod = methodStack.Peek();
                if (codeLine == null || !codeLine.IsLineEmpty)
                {
                    while (currentDepth < currentMethod.Depth ||
                           (currentDepth == currentMethod.Depth && classDefinition != null && classDefinition != currentMethod) ||
                           (currentDepth == currentMethod.Depth && method != null && method != currentMethod))
                    {
                        methodStack.Pop();
                        currentMethod = methodStack.Peek();
                    }
                }

                if (method != null)
                {
                    currentMethod.Methods.Remove_by_Name(method.Name);
                    currentMethod.Methods.Add(method);
                    methodStack.Push(method);
                    continue;
                }

                if (classDefinition != null)
                {
                    currentMethod.Classes.Remove_by_Name(classDefinition.Name);
                    currentMethod.Classes.Add(classDefinition);
                    methodStack.Push(classDefinition);
                    continue;
                }

                if (codeLine != null)
                {
                    if (codeLine.IsLineEmpty == false)
                    {
                        currentMethod.Lines.Add(codeLine);
                    }
                }
            }

            return(mainProgram);
        }
Example #10
0
        public PainCodeLine SetCodeLine(PainCodeLine compiledLine, CodeLine line)
        {
            IList <Char> lineTrimmed = line.
                                       TrimStart().
                                       ToArray();

            IList <Char>  lineBody     = line;
            EOperatorType operatorType = EOperatorType.NONE;

            // IF: wykrycie definicji IF'a
            if (lineTrimmed.Count > str_if.Length &&
                StringHelper.StrEquals(lineTrimmed.TrimStart().ToArray(), str_if, true) &&
                Char.IsWhiteSpace(lineTrimmed[str_if.Length]))
            {
                Int32 depth = GetDepth(line);
                operatorType = EOperatorType.IF;

                lineBody = lineTrimmed.
                           Substring2(str_if.Length).
                           TrimStart().
                           ToList();

                for (int i = 0; i < depth; i++)
                {
                    lineBody.Insert(0, ' ');
                }
                lineBody.TrimEnd(':');
            }
            // WHILE: wykrycie definicji WHILE'a
            else if (lineTrimmed.Count > str_while.Length &&
                     StringHelper.StrEquals(lineTrimmed.TrimStart().ToArray(), str_while, true) &&
                     Char.IsWhiteSpace(lineTrimmed[str_while.Length]))
            {
                Int32 depth = GetDepth(line);
                operatorType = EOperatorType.WHILE;

                lineBody = lineTrimmed.
                           Substring2(str_while.Length).
                           TrimStart().
                           ToList();

                for (int i = 0; i < depth; i++)
                {
                    lineBody.Insert(0, ' ');
                }
                lineBody.TrimEnd(':');
            }
            // ELSE: wykrycie definicji ELSE'a
            else if (lineTrimmed.Count >= str_else.Length &&
                     StringHelper.StrEquals(lineTrimmed.TrimStart().ToArray(), str_else, true))
            {
                Int32 depth = GetDepth(line);
                operatorType = EOperatorType.ELSE;

                lineBody = lineTrimmed.
                           Substring2(str_else.Length).
                           TrimStart().
                           ToList();

                for (int i = 0; i < depth; i++)
                {
                    lineBody.Insert(0, ' ');
                }
                lineBody.TrimEnd(':');
            }
            // ELIF: wykrycie definicji ELIF'a
            else if (lineTrimmed.Count > str_elif.Length &&
                     StringHelper.StrEquals(lineTrimmed.TrimStart().ToArray(), str_elif, true) &&
                     Char.IsWhiteSpace(lineTrimmed[str_elif.Length]))
            {
                Int32 depth = GetDepth(line);
                operatorType = EOperatorType.ELIF;

                lineBody = lineTrimmed.
                           Substring2(str_elif.Length).
                           TrimStart().
                           ToList();

                for (int i = 0; i < depth; i++)
                {
                    lineBody.Insert(0, ' ');
                }
                lineBody.TrimEnd(':');
            }
            // RETURN: wykrycie definicji RETURN'a
            else if (lineTrimmed.Count > str_return.Length &&
                     StringHelper.StrEquals(lineTrimmed.TrimStart().ToArray(), str_return, true) &&
                     Char.IsWhiteSpace(lineTrimmed[str_return.Length]))
            {
                Int32 depth = GetDepth(line);
                operatorType = EOperatorType.RETURN;

                lineBody = lineTrimmed.
                           Substring2(str_return.Length).
                           TrimStart().
                           ToList();

                for (int i = 0; i < depth; i++)
                {
                    lineBody.Insert(0, ' ');
                }
                lineBody.TrimEnd(':');
            }
            // TRY: wykrycie definicji TRY'a
            else if (lineTrimmed.Count > str_try.Length &&
                     StringHelper.StrEquals(lineTrimmed.TrimStart().ToArray(), str_try, true) /*&&
                                                                                               * Char.IsWhiteSpace(lineTrimmed[str_try.Length])*/)
            {
                Int32 depth = GetDepth(line);
                operatorType = EOperatorType.TRY;

                lineBody = lineTrimmed.
                           Substring2(str_try.Length).
                           TrimStart().
                           ToList();

                for (int i = 0; i < depth; i++)
                {
                    lineBody.Insert(0, ' ');
                }
                lineBody.TrimEnd(':');
            }
            // CATCH: wykrycie definicji CATCH'a
            else if (lineTrimmed.Count > str_catch.Length &&
                     StringHelper.StrEquals(lineTrimmed.TrimStart().ToArray(), str_catch, true) /*&&
                                                                                                 * Char.IsWhiteSpace(lineTrimmed[str_catch.Length])*/)
            {
                Int32 depth = GetDepth(line);
                operatorType = EOperatorType.CATCH;

                lineBody = lineTrimmed.
                           Substring2(str_catch.Length).
                           TrimStart().
                           ToList();

                for (int i = 0; i < depth; i++)
                {
                    lineBody.Insert(0, ' ');
                }
                lineBody.TrimEnd(':');
            }
            // FINALLY: wykrycie definicji FINALLY'a
            else if (lineTrimmed.Count > str_finally.Length &&
                     StringHelper.StrEquals(lineTrimmed.TrimStart().ToArray(), str_finally, true) /*&&
                                                                                                   * Char.IsWhiteSpace(lineTrimmed[str_finally.Length])*/)
            {
                Int32 depth = GetDepth(line);
                operatorType = EOperatorType.FINALLY;

                lineBody = lineTrimmed.
                           Substring2(str_finally.Length).
                           TrimStart().
                           ToList();

                for (int i = 0; i < depth; i++)
                {
                    lineBody.Insert(0, ' ');
                }
                lineBody.TrimEnd(':');
            }
            // THROW: wykrycie definicji THROW'a
            else if (lineTrimmed.Count > str_throw.Length &&
                     StringHelper.StrEquals(lineTrimmed.TrimStart().ToArray(), str_throw, true) /*&&
                                                                                                 * Char.IsWhiteSpace(lineTrimmed[str_THROW.Length])*/)
            {
                Int32 depth = GetDepth(line);
                operatorType = EOperatorType.THROW;

                lineBody = lineTrimmed.
                           Substring2(str_throw.Length).
                           TrimStart().
                           ToList();

                for (int i = 0; i < depth; i++)
                {
                    lineBody.Insert(0, ' ');
                }
                lineBody.TrimEnd(':');
            }

            ExpressionGroup expressionGroup = TokenizerInvariant.I.
                                              Compile(lineBody);

            if (compiledLine == null)
            {
                compiledLine = new PainCodeLine();
            }

            compiledLine.Code            = line.ToString2();
            compiledLine.ExpressionGroup = expressionGroup;
            compiledLine.OperatorType    = operatorType;
            compiledLine.IsLineEmpty     = lineTrimmed.Count == 0;
            compiledLine.Depth          += GetDepth(lineBody);

            return(compiledLine);
        }
Example #11
0
 public PainCodeLine SetCodeLine(PainCodeLine compiledLine, String line)
 {
     return(SetCodeLine(compiledLine, new CodeLine(line)));
 }
Example #12
0
        private static PainContext InvokeMethodGetContext(
            String Method,
            IList <Object> MethodParameters,
            IDictionary <String, Object> Values,
            IDictionary <String, Object> StaticValues)
        {
            PainContext newContext = CreateContext(
                new PainCodeLines(),
                Values,
                StaticValues,
                false, true);
            PainObject globalObject = newContext.GlobalObject;

            ExpressionGroup expressionGroup = new ExpressionGroup(false);

            expressionGroup.MainExpression = new Expression();
            expressionGroup.MainExpression.IsOnpExecution = false;
            expressionGroup.MainExpression.Tokens         = new ExpressionTokens();

            expressionGroup.MainExpression.Tokens.Add(
                new ExpressionToken(Method, TokenType.VARIABLE));

            expressionGroup.MainExpression.Tokens.Add(
                new ExpressionToken('@', TokenType.OPERATOR));

            expressionGroup.MainExpression.Tokens.Add(
                new ExpressionToken('(', TokenType.BRACKET_BEGIN));

            if (MethodParameters != null)
            {
                Int32 i = -1;
                foreach (Object parameter in MethodParameters)
                {
                    i++;
                    if (i > 0)
                    {
                        expressionGroup.MainExpression.Tokens.Add(
                            new ExpressionToken(',', TokenType.SEPARATOR));
                    }

                    String parameterName = IdGenerator.Generate();
                    globalObject.DynamicValues[parameterName] = parameter; // much faster
                    //newContext[parameterName] = parameter;

                    expressionGroup.MainExpression.Tokens.Add(
                        new ExpressionToken(parameterName, TokenType.VARIABLE));
                }
            }

            expressionGroup.MainExpression.Tokens.Add(
                new ExpressionToken(')', TokenType.BRACKET_END));

            PainCodeLine lineOfCode = new PainCodeLine()
            {
                ExpressionGroup = expressionGroup,
                Depth           = 0,
                IsLineEmpty     = false,
                OperatorType    = EOperatorType.RETURN
            };

            newContext.GlobalState.Program.Lines.Add(lineOfCode);

            return(newContext);
        }