164 lines
7.8 KiB
C++
164 lines
7.8 KiB
C++
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// Licensed under the MIT License.
|
|
|
|
#pragma once
|
|
/****************************Module*Header***********************************\
|
|
* Module Name: CalcEngine.h
|
|
*
|
|
* Module Description:
|
|
* The class definition for the Calculator's engine class CCalcEngine
|
|
*
|
|
* Warnings:
|
|
*
|
|
* Created: 17-Jan-2008
|
|
*
|
|
\****************************************************************************/
|
|
|
|
#include "CCommand.h"
|
|
#include "EngineStrings.h"
|
|
#include "../Command.h"
|
|
#include "../CalculatorVector.h"
|
|
#include "../ExpressionCommand.h"
|
|
#include "RadixType.h"
|
|
#include "History.h" // for History Collector
|
|
#include "CalcInput.h"
|
|
#include "CalcUtils.h"
|
|
#include "ICalcDisplay.h"
|
|
#include "Rational.h"
|
|
#include "RationalMath.h"
|
|
|
|
// The following are NOT real exports of CalcEngine, but for forward declarations
|
|
// The real exports follows later
|
|
|
|
// This is expected to be in same order as IDM_QWORD, IDM_DWORD etc.
|
|
enum eNUM_WIDTH {
|
|
QWORD_WIDTH, // Number width of 64 bits mode (default)
|
|
DWORD_WIDTH, // Number width of 32 bits mode
|
|
WORD_WIDTH, // Number width of 16 bits mode
|
|
BYTE_WIDTH // Number width of 16 bits mode
|
|
};
|
|
typedef enum eNUM_WIDTH NUM_WIDTH;
|
|
static constexpr size_t NUM_WIDTH_LENGTH = 4;
|
|
|
|
namespace CalculationManager
|
|
{
|
|
class IResourceProvider;
|
|
}
|
|
|
|
namespace CalculatorUnitTests
|
|
{
|
|
class CalcEngineTests;
|
|
}
|
|
|
|
class CCalcEngine {
|
|
public:
|
|
CCalcEngine(bool fPrecedence, bool fIntegerMode, CalculationManager::IResourceProvider* const pResourceProvider, __in_opt ICalcDisplay *pCalcDisplay, __in_opt std::shared_ptr<IHistoryDisplay> pHistoryDisplay);
|
|
void ProcessCommand(OpCode wID);
|
|
void DisplayError (uint32_t nError);
|
|
std::unique_ptr<CalcEngine::Rational> PersistedMemObject();
|
|
void PersistedMemObject(CalcEngine::Rational const& memObject);
|
|
bool FInErrorState() { return m_bError; }
|
|
bool FInRecordingState() { return m_bRecord; }
|
|
void SettingsChanged();
|
|
bool IsCurrentTooBigForTrig();
|
|
int GetCurrentRadix();
|
|
std::wstring GetCurrentResultForRadix(uint32_t radix, int32_t precision);
|
|
void ChangePrecision(int32_t precision) { m_precision = precision; ChangeConstants(m_radix, precision); }
|
|
std::wstring GroupDigitsPerRadix(std::wstring_view numberString, uint32_t radix);
|
|
std::wstring GetStringForDisplay(CalcEngine::Rational const& rat, uint32_t radix);
|
|
void UpdateMaxIntDigits();
|
|
wchar_t DecimalSeparator() const;
|
|
|
|
// Static methods for the instance
|
|
static void InitialOneTimeOnlySetup(CalculationManager::IResourceProvider& resourceProvider); // Once per load time to call to initialize all shared global variables
|
|
// returns the ptr to string representing the operator. Mostly same as the button, but few special cases for x^y etc.
|
|
static std::wstring_view GetString(int ids) { return s_engineStrings[ids]; }
|
|
static std::wstring_view OpCodeToString(int nOpCode) { return GetString(IdStrFromCmdId(nOpCode)); }
|
|
static std::wstring_view OpCodeToUnaryString(int nOpCode, bool fInv, ANGLE_TYPE angletype);
|
|
|
|
private:
|
|
bool m_fPrecedence;
|
|
bool m_fIntegerMode; /* This is true if engine is explicitly called to be in integer mode. All bases are restricted to be in integers only */
|
|
ICalcDisplay *m_pCalcDisplay;
|
|
CalculationManager::IResourceProvider* const m_resourceProvider;
|
|
int m_nOpCode; /* ID value of operation. */
|
|
int m_nPrevOpCode; // opcode which computed the number in m_currentVal. 0 if it is already bracketed or plain number or
|
|
// if it hasn't yet been computed
|
|
bool m_bChangeOp; /* Flag for changing operation. */
|
|
bool m_bRecord; // Global mode: recording or displaying
|
|
bool m_bSetCalcState; // Flag for setting the engine result state
|
|
CalcEngine::CalcInput m_input; // Global calc input object for decimal strings
|
|
eNUMOBJ_FMT m_nFE; /* Scientific notation conversion flag. */
|
|
CalcEngine::Rational m_maxTrigonometricNum;
|
|
std::unique_ptr<CalcEngine::Rational> m_memoryValue; // Current memory value.
|
|
|
|
CalcEngine::Rational m_holdVal; // For holding the second operand in repetitive calculations ( pressing "=" continuously)
|
|
|
|
CalcEngine::Rational m_currentVal; // Currently displayed number used everywhere.
|
|
CalcEngine::Rational m_lastVal; // Number before operation (left operand).
|
|
std::array<CalcEngine::Rational, MAXPRECDEPTH> m_parenVals; // Holding array for parenthesis values.
|
|
std::array<CalcEngine::Rational, MAXPRECDEPTH> m_precedenceVals; // Holding array for precedence values.
|
|
bool m_bError; // Error flag.
|
|
bool m_bInv; // Inverse on/off flag.
|
|
bool m_bNoPrevEqu; /* Flag for previous equals. */
|
|
|
|
uint32_t m_radix;
|
|
int32_t m_precision;
|
|
int m_cIntDigitsSav;
|
|
std::vector<uint32_t> m_decGrouping; // Holds the decimal digit grouping number
|
|
|
|
std::wstring m_numberString;
|
|
|
|
int m_nTempCom; /* Holding place for the last command. */
|
|
int m_openParenCount; // Number of open parentheses.
|
|
std::array<int, MAXPRECDEPTH> m_nOp; /* Holding array for parenthesis operations. */
|
|
std::array<int, MAXPRECDEPTH> m_nPrecOp; /* Holding array for precedence operations. */
|
|
size_t m_precedenceOpCount; /* Current number of precedence ops in holding. */
|
|
int m_nLastCom; // Last command entered.
|
|
ANGLE_TYPE m_angletype; // Current Angle type when in dec mode. one of deg, rad or grad
|
|
NUM_WIDTH m_numwidth; // one of qword, dword, word or byte mode.
|
|
int32_t m_dwWordBitWidth; // # of bits in currently selected word size
|
|
|
|
CHistoryCollector m_HistoryCollector; // Accumulator of each line of history as various commands are processed
|
|
|
|
std::array<CalcEngine::Rational, NUM_WIDTH_LENGTH> m_chopNumbers; // word size enforcement
|
|
std::array<std::wstring, NUM_WIDTH_LENGTH> m_maxDecimalValueStrings; // maximum values represented by a given word width based off m_chopNumbers
|
|
static std::array<std::wstring, CSTRINGSENGMAX> s_engineStrings; // the string table shared across all instances
|
|
wchar_t m_decimalSeparator;
|
|
wchar_t m_groupSeparator;
|
|
|
|
private:
|
|
void ProcessCommandWorker(OpCode wParam);
|
|
void HandleErrorCommand(OpCode idc);
|
|
void HandleMaxDigitsReached();
|
|
void DisplayNum(void);
|
|
int IsNumberInvalid(const std::wstring& numberString, int iMaxExp, int iMaxMantissa, uint32_t radix) const;
|
|
void DisplayAnnounceBinaryOperator();
|
|
void SetPrimaryDisplay(const std::wstring& szText, bool isError = false);
|
|
void ClearTemporaryValues();
|
|
CalcEngine::Rational TruncateNumForIntMath(CalcEngine::Rational const& rat);
|
|
CalcEngine::Rational SciCalcFunctions(CalcEngine::Rational const& rat, uint32_t op);
|
|
CalcEngine::Rational DoOperation(int operation, CalcEngine::Rational const& lhs, CalcEngine::Rational const& rhs);
|
|
void SetRadixTypeAndNumWidth(RADIX_TYPE radixtype, NUM_WIDTH numwidth);
|
|
int32_t DwWordBitWidthFromeNumWidth(NUM_WIDTH numwidth);
|
|
uint32_t NRadixFromRadixType( RADIX_TYPE radixtype);
|
|
|
|
bool TryToggleBit(CalcEngine::Rational& rat, uint32_t wbitno);
|
|
void CheckAndAddLastBinOpToHistory(bool addToHistory = true);
|
|
int IdcSetAngleTypeDecMode(int idc);
|
|
|
|
void InitChopNumbers();
|
|
|
|
static void LoadEngineStrings(CalculationManager::IResourceProvider& resourceProvider);
|
|
static int IdStrFromCmdId(int id) { return id - IDC_FIRSTCONTROL + IDS_FIRSTENGSTR; }
|
|
|
|
static std::vector<uint32_t> DigitGroupingStringToGroupingVector(std::wstring_view groupingString);
|
|
std::wstring GroupDigits(std::wstring_view delimiter, std::vector<uint32_t> const& grouping, std::wstring_view displayString, bool isNumNegative = false);
|
|
|
|
static int QuickLog2(int iNum);
|
|
static void ChangeBaseConstants(uint32_t radix, int maxIntDigits, int32_t precision);
|
|
void BaseOrPrecisionChanged();
|
|
|
|
friend class CalculatorUnitTests::CalcEngineTests;
|
|
};
|