Changeset 612 for trunk/CrypPluginBase


Ignore:
Timestamp:
Sep 30, 2009, 5:20:20 PM (12 years ago)
Author:
Sven Rech
Message:

expression parser works perfectly now

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPluginBase/Miscellaneous/BigInteger.cs

    r611 r612  
    33603360        }
    33613361
     3362        public BigInteger pow(BigInteger exp)
     3363        {
     3364            if (exp >= 0)
     3365            {
     3366                BigInteger tmp = 1;
     3367                for (BigInteger i = 0; i < exp; i++)
     3368                    tmp *= this;
     3369                return tmp;
     3370            }
     3371            else
     3372                throw new Exception("Pow without mod not possible with negative exponent!");
     3373        }
    33623374
    33633375        #region IComparable Members
     
    34563468        }
    34573469
    3458         private enum Priority { ALL /*whole string*/, ENDBRACKET, POW, MULTDIV, ADDSUB };
    3459 
    3460         private static BigInteger parse(Stack<TOKEN> stack, Priority priority)
     3470        private enum Priority { ALL, POW, MULTDIV, ADDSUB };
     3471
     3472        private static BigInteger parse(Stack<TOKEN> stack, Priority priority, bool endbracket)
    34613473        {
    34623474            if (stack.Count == 0)
    3463                 throw new Exception("Expression Parsing Error");
     3475                throw new Exception("Expression Parsing Error.");
    34643476            int minus = 1;
    34653477            BigInteger v = 0;
    3466             TOKEN t = stack.Pop();  //get -, + or Integer
     3478            TOKEN t = stack.Pop();  //get -, +, integer or bracket
    34673479
    34683480            if (t.ttype == TOKEN.Ttype.MINUS)
    34693481            {
    34703482                minus = -1;
    3471                 t = stack.Pop();    //get integer
     3483                t = stack.Pop();    //get integer or bracket
    34723484            }
    34733485            else if (t.ttype == TOKEN.Ttype.PLUS)
    34743486            {
    34753487                minus = 1;
    3476                 t = stack.Pop();    //get integer
     3488                t = stack.Pop();    //get integer or bracket
    34773489            }
    34783490
    34793491            if (t.ttype == TOKEN.Ttype.INTEGER)
    34803492            {
    3481 
    34823493                v = minus * t.integer;
    3483                 if (stack.Count == 0)
    3484                     if (priority == Priority.ENDBRACKET)
    3485                         throw new Exception("Expression Parsing Error (bracket close missing)");
    3486                     else
    3487                         return v;
    3488                 t = stack.Pop();    //get operator
    3489                 switch (t.ttype)
     3494            }
     3495            else if (t.ttype == TOKEN.Ttype.BRACKETOPEN)
     3496            {
     3497                v = minus * parse(stack, Priority.ALL, true);
     3498                stack.Pop();    //pop the closing bracket
     3499            }
     3500
     3501            while (stack.Count != 0)
     3502            {       
     3503                switch (stack.Peek().ttype) //next operator
    34903504                {
    34913505                    case TOKEN.Ttype.PLUS:
    3492                         if (priority == Priority.ADDSUB)
    3493                         {
    3494                             stack.Push(t);
     3506                        if (priority == Priority.MULTDIV || priority == Priority.POW)
    34953507                            return v;
    3496                         }
    3497                         v = v + parse(stack, Priority.ADDSUB);
     3508                        stack.Pop();
     3509                        v = v + parse(stack, Priority.ADDSUB, endbracket);
    34983510                        break;
    34993511                    case TOKEN.Ttype.MINUS:
    3500                         if (priority == Priority.ADDSUB)
    3501                         {
    3502                             stack.Push(t);
     3512                        if (priority == Priority.MULTDIV || priority == Priority.POW)
    35033513                            return v;
    3504                         }
    3505                         v = v - parse(stack, Priority.ADDSUB);
     3514                        stack.Pop();
     3515                        v = v - parse(stack, Priority.ADDSUB, endbracket);
    35063516                        break;
    35073517                    case TOKEN.Ttype.MULTIPLY:
    3508                         if (priority == Priority.MULTDIV)
    3509                         {
    3510                             stack.Push(t);
     3518                        if (priority == Priority.POW)
    35113519                            return v;
    3512                         }
    3513                         v = v * parse(stack, Priority.MULTDIV);
     3520                        stack.Pop();
     3521                        v = v * parse(stack, Priority.MULTDIV, endbracket);
    35143522                        break;
    35153523                    case TOKEN.Ttype.DIVIDE:
    3516                         if (priority == Priority.MULTDIV)
    3517                         {
    3518                             stack.Push(t);
     3524                        if (priority == Priority.POW)
    35193525                            return v;
    3520                         }
    3521                         v = v / parse(stack, Priority.MULTDIV);
     3526                        stack.Pop();
     3527                        v = v / parse(stack, Priority.MULTDIV, endbracket);
    35223528                        break;
    35233529                    case TOKEN.Ttype.POW:
    3524                         if (priority == Priority.POW)
    3525                         {
    3526                             stack.Push(t);
     3530                        stack.Pop();
     3531                        v = v.pow(parse(stack, Priority.POW, endbracket));
     3532                        break;
     3533                    case TOKEN.Ttype.BRACKETCLOSE:
     3534                        if (endbracket)
    35273535                            return v;
    3528                         }
    3529                         v = v / parse(stack, Priority.POW);
    3530                         break;
    3531                 }
    3532             }
    3533             else if (t.ttype == TOKEN.Ttype.BRACKETOPEN)
    3534             {
    3535                 v = minus * parse(stack, Priority.ENDBRACKET);
    3536             }
     3536                        else
     3537                            throw new Exception("Expression Parsing Error (closing bracket misplaced).");
     3538                    default:
     3539                        throw new Exception("Expression Parsing Error.");
     3540                }
     3541            }
     3542            if (endbracket)
     3543                throw new Exception("Expression Parsing Error (closing bracket missing).");
    35373544
    35383545            return v;
     
    35413548        public static BigInteger parseExpression(string expr) {
    35423549            Stack<TOKEN> stack = scan(expr);
    3543             return parse(stack, Priority.ALL);
    3544             return null;
     3550            BigInteger i = parse(stack, Priority.ALL, false);
     3551            return i;
    35453552        }
    35463553    }
Note: See TracChangeset for help on using the changeset viewer.