Ejemplo n.º 1
0
 public Service1(ConstructionContext <string> context)
 {
     _implementationType = context.ImplementationType;
     _serviceType        = context.ServiceType;
     _recipientType      = context.RecipientType;
     ExtraData           = context.Extra ?? string.Empty;
 }
Ejemplo n.º 2
0
        // expression is parsed using modified Dijkstra's shunting-yard algorithm.
        TreeNode ParseExpression(ConstructionContext context, params char[] stopSymbols)
        {
            Stack <TreeNode> termStack = new Stack <TreeNode>();
            Stack <BinaryOperatorOperation> operatorStack = new Stack <BinaryOperatorOperation>();

            termStack.Push(ParseTermWithPossibleFactorial(context));             // expression should have at least one term

            // then there should be exactly one binary operator and one term every iteration
            while (context.TryPeekNextToken(out Token token))
            {
                if (token is SymbolToken symbolToken)
                {
                    if (ParseRules.IsBinaryOperatorChar(symbolToken.Symbol))
                    {
                        context.EatLastToken();                         // eat binary operator

                        BinaryOperatorOperation curOperation = BinaryOperatorOperation.OperatorDictionary[symbolToken.Symbol.ToString()];
                        while (operatorStack.Count > 0)
                        {
                            BinaryOperatorOperation topOperation = operatorStack.Peek();
                            if ((topOperation.Precedence > curOperation.Precedence) ||
                                (topOperation.Precedence == curOperation.Precedence) && topOperation.IsLeftAssociative)
                            {
                                PopOperatorAndPushResult(termStack, operatorStack);
                            }
                            else
                            {
                                break;
                            }
                        }
                        operatorStack.Push(curOperation);

                        termStack.Push(ParseTermWithPossibleFactorial(context));
                        continue;
                    }
                    else if (stopSymbols.Contains(symbolToken.Symbol))
                    {
                        while (operatorStack.Count > 0)
                        {
                            PopOperatorAndPushResult(termStack, operatorStack);
                        }
                        return(termStack.Pop());
                    }
                }
                throw new Exception(String.Format("Unexpected token: '{0}', expected binary operator or stop-symbol", token));
            }

            if (stopSymbols.Length > 0)
            {
                throw new Exception(String.Format("Unfinished expression: expected stop symbol '{0}'", stopSymbols[0]));
            }

            while (operatorStack.Count > 0)
            {
                PopOperatorAndPushResult(termStack, operatorStack);
            }
            return(termStack.Pop());
        }
Ejemplo n.º 3
0
 internal void MergeWith(ConstructionContext constructionContext)
 {
     foreach (var element in constructionContext.series)
     {
         if (!this.series.Contains(element))
         {
             this.series.Add(element);
         }
     }
 }
Ejemplo n.º 4
0
        // stupid factorial. Why should it be after term, not before it?
        TreeNode ParseTermWithPossibleFactorial(ConstructionContext context)
        {
            TreeNode term = ParseTerm(context);

            while (context.TryPeekNextToken(out Token factorialToken) &&
                   factorialToken is SymbolToken factorialSymbolToken &&
                   factorialSymbolToken.Symbol == '!')
            {
                context.EatLastToken();                 // eat factorial token

                term = new UnaryOperationTreeNode(UnaryOperation.Factorial, term);
            }

            return(term);
        }
 internal static Service3 CreateService3WithContext(ConstructionContext <int> unused) => new Service3();
 internal static object WeakCreate(ConstructionContext <Guid> context)
 {
     return(StrongCreate(context));
 }
            internal static ClassCreatedWithAContext StrongCreate(ConstructionContext <Guid> context)
            {
                var service = new ClassCreatedWithAContext(context);

                return(service);
            }
 private ClassCreatedWithAContext(ConstructionContext <Guid> context)
 {
     Context = context;
 }
Ejemplo n.º 9
0
 internal static Service2 CreateService2WithContext(ConstructionContext <string> context)
 => new Service2(context.Extra);
Ejemplo n.º 10
0
 internal static Service1 CreateService1WithContext(ConstructionContext <string> context)
 => new Service1(context);
Ejemplo n.º 11
0
        public TreeNode BuildTree(ConstructionContext context)
        {
            List <TreeNode>  parameters  = new List <TreeNode>();
            List <TreeNode>  expressions = new List <TreeNode>();
            var              statements  = new List <TreeNode>();
            FunctionTreeNode func;
            string           name           = "Undefined";
            string           expressionName = "Undefined";

            for (int i = 0; i < context.tokens.Length; ++i)
            {
                context.TryGetNextToken(out Token token);
                switch (token)
                {
                case IdentifierToken identifierToken:                        //maybe add check for defined functions
                    name = identifierToken.ToString();                       //if we here, its function
                    break;

                case NumberToken numberToken:
                    parameters.Add(new NumberTreeNode(int.Parse(numberToken.ToString())));
                    break;

                case StringToken stringToken:
                    parameters.Add(new StringTreeNode(stringToken.ToString()));
                    break;

                case SymbolToken symbolToken:
                    break;

                case KeywordToken keywordToken:
                    name = keywordToken.ToString();

                    if (context.TryGetNextToken(out Token tok))
                    {
                        if (tok.ToString() == "(")
                        {
                            for (; ;)                                    //read arguments
                            {
                                context.TryGetNextToken(out Token token1);
                                if (token1 is NumberToken)
                                {
                                    parameters.Add(new NumberTreeNode(int.Parse(token1.ToString())));
                                }
                                else if (token1.ToString() == ",")
                                {
                                }
                                else if (token1.ToString() == ")")
                                {
                                    break;
                                }
                                else
                                {
                                    throw new ArgumentException($"Unexpected parameter {token1.ToString()}");
                                }
                            }
                        }
                        context.TryGetNextToken(out Token tok2);
                        if (tok2 == null)
                        {
                            throw new ArgumentException($"Must be open and close brackets in \"{name}\" cycle");
                        }
                        else if (tok2.ToString() == "{")
                        {
                            for (; ;)                                     //read expressions
                            {
                                if (context.TryGetNextToken(out Token token1))
                                {
                                    switch (token1)
                                    {
                                    case IdentifierToken identifierToken:

                                        expressionName = identifierToken.ToString();
                                        break;

                                    case NumberToken numberToken:
                                        expressions.Add(new NumberTreeNode(int.Parse(numberToken.ToString())));
                                        break;

                                    case StringToken stringToken:
                                        expressions.Add(new StringTreeNode(stringToken.ToString()));
                                        break;

                                    case SymbolToken symbolToken:
                                        if (symbolToken.ToString() == ")")
                                        {
                                            statements.Add(new FunctionTreeNode(expressionName, expressions.ToArray()));
                                            expressions.Clear();
                                        }
                                        break;
                                    }
                                }
                                if (token1 == null)
                                {
                                    //throw new ArgumentException($"Unexpected token \"{token1}\"");
                                    throw new ArgumentException($"Need close brace!");
                                }
                                if (token1.ToString() == "}")
                                {
                                    return(new CycleTreeNode(name, statements.ToArray(), parameters.ToArray()));
                                }
                                //else
                                //throw new ArgumentException($"Unexpected expression in cycle {token1.ToString()}");
                            }
                        }

                        else
                        {
                            throw new ArgumentException($"Unexpected expression{tok2.ToString()}");
                        }
                    }
                    else
                    {
                        throw new ArgumentException($"Cycle \"{name}\" must be have open and close braces");                                //when we have Repeat without brackets
                    }

                default:
                    throw new ArgumentException($"Something wrong in your code {token}");
                }
            }

            func = new FunctionTreeNode(name, parameters.ToArray());
            return(func);
        }
Ejemplo n.º 12
0
        public TreeNode Construct(Token[] tokens)
        {
            ConstructionContext context = new ConstructionContext(tokens);

            return(BuildTree(context));
        }
Ejemplo n.º 13
0
        TreeNode ParseTerm(ConstructionContext context)
        {
            if (!context.TryGetNextToken(out Token token))
            {
                throw new Exception("No tokens for term to parse");
            }

            switch (token)
            {
            case SymbolToken symbolToken:
            {
                // (expression)
                if (symbolToken.Symbol == '(')
                {
                    TreeNode node = ParseExpression(context, ')');
                    context.EatLastToken();                             // eat right brackets
                    return(node);
                }
                // |expression|
                else if (symbolToken.Symbol == '|')
                {
                    TreeNode node = ParseExpression(context, '|');
                    context.EatLastToken();                             // eat right brackets
                    return(new UnaryOperationTreeNode(UnaryOperation.AbsoluteValue, node));
                }
                // -term
                else if (symbolToken.Symbol == '-')
                {
                    return(new UnaryOperationTreeNode(UnaryOperation.Negative, ParseTermWithPossibleFactorial(context)));
                }
                // +term
                else if (symbolToken.Symbol == '+')
                {
                    return(ParseTermWithPossibleFactorial(context));
                }
                throw new Exception(String.Format("Unexpected symbol token when parsing term: '{0}'", symbolToken.Symbol));
            }

            case IdentifierToken identifierToken:
            {
                // variable
                if (!context.TryPeekNextToken(out Token nextToken))
                {
                    return(new UndefinedVariableTreeNode(identifierToken.Identifier));
                }
                else if (!(nextToken is SymbolToken nextSymbolToken && nextSymbolToken.Symbol == '('))
                {
                    return(new UndefinedVariableTreeNode(identifierToken.Identifier));
                }

                // if we are here, then it's a function
                context.EatLastToken();                         // eat left brackets

                // check if it has any parameters
                // func()
                if (context.TryPeekNextToken(out Token emptyFuncToken) &&
                    emptyFuncToken is SymbolToken emptyFuncSymbolToken &&
                    emptyFuncSymbolToken.Symbol == ')')
                {
                    context.EatLastToken();                             // eat right brackets
                    return(new UndefinedFunctionTreeNode(identifierToken.Identifier, new TreeNode[0]));
                }

                // parse each parameter
                // func(expression, ...)
                List <TreeNode> parameters = new List <TreeNode>();
                while (true)
                {
                    TreeNode parameter = ParseExpression(context, ',', ')');
                    parameters.Add(parameter);

                    if (context.TryGetNextToken(out Token delimToken) && delimToken is SymbolToken delimSymbolToken)
                    {
                        if (delimSymbolToken.Symbol == ',')
                        {
                            continue;
                        }
                        if (delimSymbolToken.Symbol == ')')
                        {
                            break;
                        }
                        throw new Exception(String.Format("Can't parse function (unknown delimeter token '{0}')", delimSymbolToken));
                    }
                }

                return(new UndefinedFunctionTreeNode(identifierToken.Identifier, parameters.ToArray()));
            }

            // literal
            case NumberToken numberToken:
            {
                return(new NumberTreeNode(numberToken.Value));
            }
            }

            throw new Exception(String.Format("Unknown token type: '{0}'", token));
        }