Exemple #1
0
        static List <Priority> pack(List <Priority> expression)
        {
            List <object> result         = new List <object>();
            int           i              = 0;
            bool          isHighPriority = true;

            while (isHighPriority)
            {
                if (expression[i]._priority == 2)
                {
                    SortedExpression sortedExpression = new SortedExpression(expression[i - 1], expression[i + 1], expression[i]);
                    Priority         priority         = new Priority(sortedExpression, 0);
                    expression[i - 1] = priority;
                    expression.RemoveAt(i + 1);
                    expression.RemoveAt(i);
                    --i;
                }
                bool haveHighPriority = false;
                foreach (Priority priority in expression)
                {
                    if (priority._priority == 2)
                    {
                        haveHighPriority = true;
                    }
                }
                isHighPriority = haveHighPriority;
                ++i;
            }
            return(expression);
        }
Exemple #2
0
        static void passTree(List <Priority> expression)
        {
            for (int i = 0; i != expression.Count; ++i)
            {
                try
                {
                    Token token = (Token)expression[i]._element;
                    //записываешь в массив значение по индексу i
                }
                catch
                {
                    SortedExpression sortExpression = (SortedExpression)expression[i]._element; // * или /
                    runSortExpression(sortExpression, true);
                    //записываешь значение переменной l в массив по индексу i
                }
            }

            //проходишь массив и складываешь и вычитаешь
        }
Exemple #3
0
 static void runSortExpression(SortedExpression sortExpression, bool isLeft)
 {
     try
     {
         //не содержит вложенностей
         Token left    = (Token)sortExpression._left; //если не имеет вложенностей левый операнд
         Token right   = (Token)sortExpression._right;
         Token operand = (Token)sortExpression._operand;
         //сохраняешь в переменную результат вычисления
         if (isLeft)
         {
             //l = left * right
         }
         else
         {
             //r = left + right
         }
     }
     catch
     {
         try //вложенность содержить правый элемент
         {
             Token left    = (Token)sortExpression._left;
             Token operand = (Token)sortExpression._operand;
             runSortExpression((SortedExpression)sortExpression._right, false);
             if (isLeft)
             {
                 //l = left + r
             }
             else
             {
                 //r = left + r
             }
         }
         catch
         {
             try
             {
                 //левый содержит вложенность
                 Token right   = (Token)sortExpression._right;
                 Token operand = (Token)sortExpression._operand;
                 runSortExpression((SortedExpression)sortExpression._left, true);
                 if (isLeft)
                 {
                     //l = l + right
                 }
                 else
                 {
                     //r = l + right
                 }
             }
             catch
             { //оба содержат вложенность
                 runSortExpression((SortedExpression)sortExpression._left, true);
                 runSortExpression((SortedExpression)sortExpression._right, false);
                 Token operand = (Token)sortExpression._operand;
                 if (isLeft)
                 {
                     //l = l + r
                 }
                 else
                 {
                     //r = l + r
                 }
             }
         }
     }
 }