Beispiel #1
0
        private string changeBitnessHelper(string bin, string dec, int MAX, CalcViews.Programmer.ProgrammerCalcBits currentBits, CalcViews.Programmer.ProgrammerCalcBits prevBits)
        {
            string retVal = string.Empty;

            // First we'll resize the bin string to have the right number of bits
            // per the prevBits value
            int prevMax = (prevBits == CalcViews.Programmer.ProgrammerCalcBits.Qword) ? LONG :
                          (prevBits == CalcViews.Programmer.ProgrammerCalcBits.Dword) ? INT :
                          (prevBits == CalcViews.Programmer.ProgrammerCalcBits.Word) ? SHORT : BYTE;

            int count = prevMax - bin.Length;

            for (int i = 0; i < count; i++)
            {
                bin = "0" + bin;
            }

            if (bin.StartsWith("1"))
            {
                count = MAX - bin.Length;
                string tempExp = string.Empty;

                for (int i = 0; i < count; i++)
                {
                    tempExp += "1";
                }

                return(CalcHelpers.bin2Dec(tempExp + bin, (currentView as ProgrammerView).currentBits));
            }

            return(dec);
        }
Beispiel #2
0
        public string GetDecimal(List <int> bin)
        {
            if (!_mainPage.isProgrammer())
            {
                return(string.Empty);
            }

            string exp = string.Empty;

            foreach (int b in bin)
            {
                exp += b.ToString();
            }

            return(CalcHelpers.bin2Dec(exp, (currentView as ProgrammerView).currentBits));
        }
Beispiel #3
0
        // always returns "64-bit" representation
        public List <int> GetBinary()
        {
            if (!_mainPage.isProgrammer())
            {
                return(new List <int>());
            }

            string bin = CalcHelpers.dec2Bin(Get(), (currentView as ProgrammerView).currentBits).PadLeft(MAX_BITNESS, '0');

            List <int> binArray = new List <int>();

            foreach (char c in bin.ToCharArray())
            {
                binArray.Add(int.Parse(c.ToString()));
            }

            return(binArray);
        }
Beispiel #4
0
        private string GetDecimal(string exp, bool asLong)
        {
            string dec = exp;

            if (!_mainPage.isProgrammer())
            {
                return(dec);
            }

            if (asLong)
            {
                if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Hex)
                {
                    dec = CalcViews.Programmer.hex2Long(exp);
                }
                else if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Oct)
                {
                    dec = CalcViews.Programmer.oct2Long(exp);
                }
                else if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Bin)
                {
                    dec = CalcViews.Programmer.bin2Long(exp);
                }
            }

            else
            {
                if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Hex)
                {
                    dec = CalcHelpers.hex2Dec(exp, (currentView as ProgrammerView).currentBits);
                }
                else if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Oct)
                {
                    dec = CalcHelpers.oct2Dec(exp, (currentView as ProgrammerView).currentBits);
                }
                else if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Bin)
                {
                    dec = CalcHelpers.bin2Dec(exp, (currentView as ProgrammerView).currentBits);
                }
            }

            return(dec);
        }
Beispiel #5
0
        private string GetExpression(string dec, bool asLong)
        {
            string exp = dec;

            if (!_mainPage.isProgrammer())
            {
                return(exp);
            }

            if (asLong)
            {
                if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Hex)
                {
                    exp = CalcViews.Programmer.dec2Long(dec, 16);
                }
                else if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Oct)
                {
                    exp = CalcViews.Programmer.dec2Long(dec, 8);
                }
                else if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Bin)
                {
                    exp = CalcViews.Programmer.dec2Long(dec, 2);
                }
            }

            else
            {
                if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Hex)
                {
                    exp = CalcHelpers.dec2Hex(dec, (currentView as ProgrammerView).currentBits);
                }
                else if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Oct)
                {
                    exp = CalcHelpers.dec2Oct(dec, (currentView as ProgrammerView).currentBits);
                }
                else if ((currentView as ProgrammerView).calcState == Calc_MainPage.CalcStateValues.Bin)
                {
                    exp = CalcHelpers.dec2Bin(dec, (currentView as ProgrammerView).currentBits);
                }
            }

            return(exp);
        }
Beispiel #6
0
        /// <summary>
        /// Converts a standard infix expression to list of tokens in
        /// postfix order.
        /// </summary>
        /// <param name="expression">Expression to evaluate</param>
        /// <returns></returns>
        protected List <string> TokenizeExpression(string expression)
        {
            List <string>  tokens     = new List <string>();
            Stack <string> stack      = new Stack <string>();
            State          state      = State.None;
            int            parenCount = 0;
            string         temp;

            TextParser parser = new TextParser(expression);

            while (!parser.EndOfText)
            {
                if (Char.IsWhiteSpace(parser.Peek()))
                {
                    // Ignore spaces, tabs, etc.
                }
                else if (parser.Peek() == '(')
                {
                    // Cannot follow operand
                    if (state == State.Operand)
                    {
                        throw new EvalException(ErrOperatorExpected, parser.Position);
                    }
                    // Allow additional unary operators after "("
                    if (state == State.UnaryOperator)
                    {
                        state = State.Operator;
                    }
                    // Push opening parenthesis onto stack
                    stack.Push(parser.Peek().ToString());
                    // Track number of parentheses
                    parenCount++;
                }
                else if (parser.Peek() == ')')
                {
                    // Must follow operand
                    if (state != State.Operand)
                    {
                        throw new EvalException(ErrOperandExpected, parser.Position);
                    }
                    // Must have matching open parenthesis
                    if (parenCount == 0)
                    {
                        throw new EvalException(ErrUnmatchedClosingParen, parser.Position);
                    }
                    // Pop all operators until matching "(" found
                    temp = stack.Pop();
                    while (temp != "(")
                    {
                        tokens.Add(temp);
                        temp = stack.Pop();
                    }
                    // Track number of parentheses
                    parenCount--;
                }
                else if ("+-*/^&|⊕<>%÷×CP".Contains(parser.Peek().ToString()))
                {
                    // Need a bit of extra code to support unary operators
                    if (state == State.Operand)
                    {
                        // Pop operators with precedence >= current operator
                        int currPrecedence = CalcHelpers.determineOPValue(parser.Peek().ToString());
                        while (stack.Count > 0 && CalcHelpers.determineOPValue(stack.Peek()) >= currPrecedence)
                        {
                            tokens.Add(stack.Pop());
                        }
                        stack.Push(parser.Peek().ToString());
                        state = State.Operator;
                    }
                    else if (state == State.UnaryOperator)
                    {
                        // Don't allow two unary operators together
                        throw new EvalException(ErrOperandExpected, parser.Position);
                    }
                    else
                    {
                        // Test for unary operator
                        if (parser.Peek() == '-')
                        {
                            // Push unary minus
                            stack.Push(UnaryMinus);
                            state = State.UnaryOperator;
                        }
                        else if (parser.Peek() == '+')
                        {
                            // Just ignore unary plus
                            state = State.UnaryOperator;
                        }
                        else
                        {
                            throw new EvalException(ErrOperandExpected, parser.Position);
                        }
                    }
                }
                else if (Char.IsDigit(parser.Peek()) || parser.Peek() == '.')
                {
                    if (state == State.Operand)
                    {
                        // Cannot follow other operand
                        throw new EvalException(ErrOperatorExpected, parser.Position);
                    }
                    // Parse number
                    temp = ParseNumberToken(parser);
                    tokens.Add(temp);
                    state = State.Operand;
                    continue;
                }
                else
                {
                    double result;

                    // Parse symbols and functions
                    if (state == State.Operand)
                    {
                        // Symbol or function cannot follow other operand
                        throw new EvalException(ErrOperatorExpected, parser.Position);
                    }

                    // TBD ADD ADDITIONAL OPERATORS HERE
                    if (!Char.IsLetter(parser.Peek()) &&
                        parser.Peek() != '√' &&
                        parser.Peek() != '!' ||
                        parser.Peek() == '_')
                    {
                        // Invalid character
                        temp = String.Format(ErrUnexpectedCharacter, parser.Peek());
                        throw new EvalException(temp, parser.Position);
                    }
                    // Save start of symbol for error reporting
                    int symbolPos = parser.Position;
                    // Parse this symbol
                    temp = ParseSymbolToken(parser);
                    // Skip whitespace
                    parser.MovePastWhitespace();


                    // Check for parameter list
                    bool   wasString    = false;
                    string stringResult = string.Empty;
                    if (parser.Peek() == '(')
                    {
                        wasString = true;

                        // Found parameter list, evaluate function
                        stringResult = EvaluateFunction(parser, temp, symbolPos);
                        result       = Convert.ToDouble(stringResult);
                    }
                    else
                    {
                        // No parameter list, evaluate symbol (variable)
                        result = EvaluateSymbol(temp, symbolPos);
                    }
                    //// Handle negative result
                    if (result < 0)
                    {
                        stack.Push(UnaryMinus);
                        result       = Math.Abs(result);
                        stringResult = stringResult.Substring(1);
                    }

                    if (wasString)
                    {
                        tokens.Add(stringResult);
                    }
                    else
                    {
                        tokens.Add(result.ToString());
                    }

                    state = State.Operand;
                    continue;
                }
                parser.MoveAhead();
            }
            // Expression cannot end with operator
            if (state == State.Operator || state == State.UnaryOperator)
            {
                throw new EvalException(ErrOperandExpected, parser.Position);
            }
            // Check for balanced parentheses
            if (parenCount > 0)
            {
                throw new EvalException(ErrClosingParenExpected, parser.Position);
            }
            // Retrieve remaining operators from stack
            while (stack.Count > 0)
            {
                tokens.Add(stack.Pop());
            }
            return(tokens);
        }
Beispiel #7
0
        public void ChangeBitness(CalcViews.Programmer.ProgrammerCalcBits prevBits)
        {
            if (!_mainPage.isProgrammer())
            {
                _mainPage.initCalcError();
                return;
            }

            string dec = Get();
            string bin = CalcViews.Programmer.dec2Long(dec, 2);

            // next if the user has chosen a specific bitness
            if ((currentView as ProgrammerView).currentBits == CalcViews.Programmer.ProgrammerCalcBits.Qword)
            {
                // ASSUME we're comming from a lower order bit
                dec = changeBitnessHelper(bin, dec, LONG, (currentView as ProgrammerView).currentBits, prevBits);
            }
            else if ((currentView as ProgrammerView).currentBits == CalcViews.Programmer.ProgrammerCalcBits.Dword)
            {
                // if we're going down in bitness
                if (bin.Length > INT)
                {
                    bin = bin.Substring(bin.Length - INT);
                    dec = CalcHelpers.bin2Dec(bin, (currentView as ProgrammerView).currentBits);
                }

                // if we're going up in bitness
                else
                {
                    dec = changeBitnessHelper(bin, dec, INT, (currentView as ProgrammerView).currentBits, prevBits);
                }
            }
            else if ((currentView as ProgrammerView).currentBits == CalcViews.Programmer.ProgrammerCalcBits.Word)
            {
                // if we're going down in bitness
                if (bin.Length > SHORT)
                {
                    bin = bin.Substring(bin.Length - SHORT);
                    dec = CalcHelpers.bin2Dec(bin, (currentView as ProgrammerView).currentBits);
                }

                // if we're going up in bitness
                else
                {
                    dec = changeBitnessHelper(bin, dec, SHORT, (currentView as ProgrammerView).currentBits, prevBits);
                }
            }
            else if ((currentView as ProgrammerView).currentBits == CalcViews.Programmer.ProgrammerCalcBits.Byte)
            {
                // if we're going down in bitness
                if (bin.Length > BYTE)
                {
                    bin = bin.Substring(bin.Length - BYTE);
                    //dec = mainPage.bin2Dec(bin);
                }

                // can't go smaller than byte
                dec = CalcHelpers.bin2Dec(bin, (currentView as ProgrammerView).currentBits);
            }

            Set(dec, GetLastInputType(), true);
        }