DevWiki/calculator
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Enable code analysis in the CalcManager project (#689)

Browse Source
This commit is contained in:
Matt Cooley 2019-11-04 07:41:13 -08:00 committed by GitHub
parent 62c45d9d1e
commit 44e1984f6b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 82 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/CalcManager/CalcManager.vcxproj
View File

@ -78,24 +78,32 @@
<UseDebugLibraries>false</UseDebugLibraries> <UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization> <WholeProgramOptimization>true</WholeProgramOptimization>
<PlatformToolset>v142</PlatformToolset> <PlatformToolset>v142</PlatformToolset>
<CodeAnalysisRuleSet>NativeRecommendedRules.ruleset</CodeAnalysisRuleSet>
<RunCodeAnalysis>true</RunCodeAnalysis>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType> <ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries> <UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization> <WholeProgramOptimization>true</WholeProgramOptimization>
<PlatformToolset>v142</PlatformToolset> <PlatformToolset>v142</PlatformToolset>
<CodeAnalysisRuleSet>NativeRecommendedRules.ruleset</CodeAnalysisRuleSet>
<RunCodeAnalysis>true</RunCodeAnalysis>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType> <ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries> <UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization> <WholeProgramOptimization>true</WholeProgramOptimization>
<PlatformToolset>v142</PlatformToolset> <PlatformToolset>v142</PlatformToolset>
<CodeAnalysisRuleSet>NativeRecommendedRules.ruleset</CodeAnalysisRuleSet>
<RunCodeAnalysis>true</RunCodeAnalysis>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration"> <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType> <ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries> <UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization> <WholeProgramOptimization>true</WholeProgramOptimization>
<PlatformToolset>v142</PlatformToolset> <PlatformToolset>v142</PlatformToolset>
<CodeAnalysisRuleSet>NativeRecommendedRules.ruleset</CodeAnalysisRuleSet>
<RunCodeAnalysis>true</RunCodeAnalysis>
</PropertyGroup> </PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'"> <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
@ -175,6 +183,7 @@
<WarningLevel>Level4</WarningLevel> <WarningLevel>Level4</WarningLevel>
<TreatWarningAsError>true</TreatWarningAsError> <TreatWarningAsError>true</TreatWarningAsError>
<ForcedIncludeFiles>pch.h</ForcedIncludeFiles> <ForcedIncludeFiles>pch.h</ForcedIncludeFiles>
<EnablePREfast>true</EnablePREfast>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
@ -209,6 +218,7 @@
<WarningLevel>Level4</WarningLevel> <WarningLevel>Level4</WarningLevel>
<TreatWarningAsError>true</TreatWarningAsError> <TreatWarningAsError>true</TreatWarningAsError>
<ForcedIncludeFiles>pch.h</ForcedIncludeFiles> <ForcedIncludeFiles>pch.h</ForcedIncludeFiles>
<EnablePREfast>true</EnablePREfast>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
@ -244,6 +254,7 @@
<WarningLevel>Level4</WarningLevel> <WarningLevel>Level4</WarningLevel>
<TreatWarningAsError>true</TreatWarningAsError> <TreatWarningAsError>true</TreatWarningAsError>
<ForcedIncludeFiles>pch.h</ForcedIncludeFiles> <ForcedIncludeFiles>pch.h</ForcedIncludeFiles>
<EnablePREfast>true</EnablePREfast>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>
@ -278,6 +289,7 @@
<WarningLevel>Level4</WarningLevel> <WarningLevel>Level4</WarningLevel>
<TreatWarningAsError>true</TreatWarningAsError> <TreatWarningAsError>true</TreatWarningAsError>
<ForcedIncludeFiles>pch.h</ForcedIncludeFiles> <ForcedIncludeFiles>pch.h</ForcedIncludeFiles>
<EnablePREfast>true</EnablePREfast>
</ClCompile> </ClCompile>
<Link> <Link>
<SubSystem>Console</SubSystem> <SubSystem>Console</SubSystem>

6
src/CalcManager/CalculatorHistory.cpp
View File

@ -39,7 +39,7 @@ CalculatorHistory::CalculatorHistory(size_t maxSize)
unsigned int CalculatorHistory::AddToHistory( unsigned int CalculatorHistory::AddToHistory(
_In_ shared_ptr<vector<pair<wstring, int>>> const& tokens, _In_ shared_ptr<vector<pair<wstring, int>>> const& tokens,
_In_ shared_ptr<vector<shared_ptr<IExpressionCommand>>> const& commands, _In_ shared_ptr<vector<shared_ptr<IExpressionCommand>>> const& commands,
_In_ wstring_view result) wstring_view result)
{ {
unsigned int addedIndex; unsigned int addedIndex;
shared_ptr<HISTORYITEM> spHistoryItem = make_shared<HISTORYITEM>(); shared_ptr<HISTORYITEM> spHistoryItem = make_shared<HISTORYITEM>();
@ -70,7 +70,7 @@ unsigned int CalculatorHistory::AddItem(_In_ shared_ptr<HISTORYITEM> const& spHi
return lastIndex; return lastIndex;
} }
bool CalculatorHistory::RemoveItem(_In_ unsigned int uIdx) bool CalculatorHistory::RemoveItem(unsigned int uIdx)
{ {
if (uIdx > m_historyItems.size() - 1) if (uIdx > m_historyItems.size() - 1)
{ {
@ -86,7 +86,7 @@ vector<shared_ptr<HISTORYITEM>> const& CalculatorHistory::GetHistory()
return m_historyItems; return m_historyItems;
} }
shared_ptr<HISTORYITEM> const& CalculatorHistory::GetHistoryItem(_In_ unsigned int uIdx) shared_ptr<HISTORYITEM> const& CalculatorHistory::GetHistoryItem(unsigned int uIdx)
{ {
assert(uIdx >= 0 && uIdx < m_historyItems.size()); assert(uIdx >= 0 && uIdx < m_historyItems.size());
return m_historyItems.at(uIdx); return m_historyItems.at(uIdx);

2
src/CalcManager/CalculatorManager.h
View File

@ -102,7 +102,7 @@ namespace CalculationManager
void BinaryOperatorReceived() override; void BinaryOperatorReceived() override;
void MemoryItemChanged(unsigned int indexOfMemory) override; void MemoryItemChanged(unsigned int indexOfMemory) override;
void InputChanged() override; void InputChanged() override;
CalculatorManager(ICalcDisplay* displayCallback, IResourceProvider* resourceProvider); CalculatorManager(_In_ ICalcDisplay* displayCallback, _In_ IResourceProvider* resourceProvider);
void Reset(bool clearMemory = true); void Reset(bool clearMemory = true);
void SetStandardMode(); void SetStandardMode();

6
src/CalcManager/Ratpack/basex.cpp
View File

@ -34,7 +34,7 @@ void _mulnumx(PNUMBER* pa, PNUMBER b);
// //
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void mulnumx(PNUMBER* pa, PNUMBER b) void mulnumx(_Inout_ PNUMBER* pa, _In_ PNUMBER b)
{ {
if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0) if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0)
@ -172,7 +172,7 @@ void _mulnumx(PNUMBER* pa, PNUMBER b)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void numpowi32x(_Inout_ PNUMBER* proot, _In_ int32_t power) void numpowi32x(_Inout_ PNUMBER* proot, int32_t power)
{ {
PNUMBER lret = i32tonum(1, BASEX); PNUMBER lret = i32tonum(1, BASEX);
@ -215,7 +215,7 @@ void _divnumx(PNUMBER* pa, PNUMBER b, int32_t precision);
// //
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void divnumx(PNUMBER* pa, PNUMBER b, int32_t precision) void divnumx(_Inout_ PNUMBER* pa, _In_ PNUMBER b, int32_t precision)
{ {
if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0) if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0)

8
src/CalcManager/Ratpack/conv.cpp
View File

@ -145,7 +145,7 @@ void _dupnum(_In_ PNUMBER dest, _In_ const NUMBER* const src)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void _destroynum(_In_ PNUMBER pnum) void _destroynum(_Frees_ptr_opt_ PNUMBER pnum)
{ {
if (pnum != nullptr) if (pnum != nullptr)
@ -167,7 +167,7 @@ void _destroynum(_In_ PNUMBER pnum)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void _destroyrat(_In_ PRAT prat) void _destroyrat(_Frees_ptr_opt_ PRAT prat)
{ {
if (prat != nullptr) if (prat != nullptr)
@ -760,7 +760,7 @@ PNUMBER StringToNumber(wstring_view numberString, uint32_t radix, int32_t precis
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
PRAT i32torat(_In_ int32_t ini32) PRAT i32torat(int32_t ini32)
{ {
PRAT pratret = nullptr; PRAT pratret = nullptr;
@ -784,7 +784,7 @@ PRAT i32torat(_In_ int32_t ini32)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
PRAT Ui32torat(_In_ uint32_t inui32) PRAT Ui32torat(uint32_t inui32)
{ {
PRAT pratret = nullptr; PRAT pratret = nullptr;

14
src/CalcManager/Ratpack/exp.cpp
View File

@ -39,7 +39,7 @@
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void _exprat(PRAT* px, int32_t precision) void _exprat(_Inout_ PRAT* px, int32_t precision)
{ {
CREATETAYLOR(); CREATETAYLOR();
@ -58,7 +58,7 @@ void _exprat(PRAT* px, int32_t precision)
DESTROYTAYLOR(); DESTROYTAYLOR();
} }
void exprat(PRAT* px, uint32_t radix, int32_t precision) void exprat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
PRAT pwr = nullptr; PRAT pwr = nullptr;
@ -150,7 +150,7 @@ void _lograt(PRAT* px, int32_t precision)
DESTROYTAYLOR(); DESTROYTAYLOR();
} }
void lograt(PRAT* px, int32_t precision) void lograt(_Inout_ PRAT* px, int32_t precision)
{ {
bool fneglog; bool fneglog;
@ -224,7 +224,7 @@ void lograt(PRAT* px, int32_t precision)
destroyrat(pwr); destroyrat(pwr);
} }
void log10rat(PRAT* px, int32_t precision) void log10rat(_Inout_ PRAT* px, int32_t precision)
{ {
lograt(px, precision); lograt(px, precision);
@ -267,7 +267,7 @@ bool IsEven(PRAT x, uint32_t radix, int32_t precision)
// //
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void powrat(PRAT* px, PRAT y, uint32_t radix, int32_t precision) void powrat(_Inout_ PRAT* px, _In_ PRAT y, uint32_t radix, int32_t precision)
{ {
// Handle cases where px or y is 0 by calling powratcomp directly // Handle cases where px or y is 0 by calling powratcomp directly
if (zerrat(*px) || zerrat(y)) if (zerrat(*px) || zerrat(y))
@ -294,7 +294,7 @@ void powrat(PRAT* px, PRAT y, uint32_t radix, int32_t precision)
} }
} }
void powratNumeratorDenominator(PRAT* px, PRAT y, uint32_t radix, int32_t precision) void powratNumeratorDenominator(_Inout_ PRAT* px, _In_ PRAT y, uint32_t radix, int32_t precision)
{ {
// Prepare rationals // Prepare rationals
PRAT yNumerator = nullptr; PRAT yNumerator = nullptr;
@ -403,7 +403,7 @@ void powratNumeratorDenominator(PRAT* px, PRAT y, uint32_t radix, int32_t precis
// //
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void powratcomp(PRAT* px, PRAT y, uint32_t radix, int32_t precision) void powratcomp(_Inout_ PRAT* px, _In_ PRAT y, uint32_t radix, int32_t precision)
{ {
int32_t sign = SIGN(*px); int32_t sign = SIGN(*px);

2
src/CalcManager/Ratpack/fact.cpp
View File

@ -190,7 +190,7 @@ void _gamma(PRAT* pn, uint32_t radix, int32_t precision)
destroyrat(sum); destroyrat(sum);
} }
void factrat(PRAT* px, uint32_t radix, int32_t precision) void factrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
PRAT fact = nullptr; PRAT fact = nullptr;

6
src/CalcManager/Ratpack/itrans.cpp
View File

@ -83,7 +83,7 @@ void asinanglerat(_Inout_ PRAT* pa, ANGLE_TYPE angletype, uint32_t radix, int32_
ascalerat(pa, angletype, precision); ascalerat(pa, angletype, precision);
} }
void asinrat(PRAT* px, uint32_t radix, int32_t precision) void asinrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
PRAT pret = nullptr; PRAT pret = nullptr;
@ -190,7 +190,7 @@ void _acosrat(PRAT* px, int32_t precision)
DESTROYTAYLOR(); DESTROYTAYLOR();
} }
void acosrat(PRAT* px, uint32_t radix, int32_t precision) void acosrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
int32_t sgn = SIGN(*px); int32_t sgn = SIGN(*px);
@ -276,7 +276,7 @@ void _atanrat(PRAT* px, int32_t precision)
DESTROYTAYLOR(); DESTROYTAYLOR();
} }
void atanrat(PRAT* px, uint32_t radix, int32_t precision) void atanrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
PRAT tmpx = nullptr; PRAT tmpx = nullptr;

8
src/CalcManager/Ratpack/itransh.cpp
View File

@ -1,4 +1,4 @@
// Copyright (c) Microsoft Corporation. All rights reserved. // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. // Licensed under the MIT License.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -47,7 +47,7 @@
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void asinhrat(PRAT* px, uint32_t radix, int32_t precision) void asinhrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
PRAT neg_pt_eight_five = nullptr; PRAT neg_pt_eight_five = nullptr;
@ -101,7 +101,7 @@ void asinhrat(PRAT* px, uint32_t radix, int32_t precision)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void acoshrat(PRAT* px, uint32_t radix, int32_t precision) void acoshrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
if (rat_lt(*px, rat_one, precision)) if (rat_lt(*px, rat_one, precision))
@ -138,7 +138,7 @@ void acoshrat(PRAT* px, uint32_t radix, int32_t precision)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void atanhrat(PRAT* px, int32_t precision) void atanhrat(_Inout_ PRAT* px, int32_t precision)
{ {
PRAT ptmp = nullptr; PRAT ptmp = nullptr;

14
src/CalcManager/Ratpack/logic.cpp
View File

@ -17,7 +17,7 @@
using namespace std; using namespace std;
void lshrat(PRAT* pa, PRAT b, uint32_t radix, int32_t precision) void lshrat(_Inout_ PRAT* pa, _In_ PRAT b, uint32_t radix, int32_t precision)
{ {
PRAT pwr = nullptr; PRAT pwr = nullptr;
@ -40,7 +40,7 @@ void lshrat(PRAT* pa, PRAT b, uint32_t radix, int32_t precision)
} }
} }
void rshrat(PRAT* pa, PRAT b, uint32_t radix, int32_t precision) void rshrat(_Inout_ PRAT* pa, _In_ PRAT b, uint32_t radix, int32_t precision)
{ {
PRAT pwr = nullptr; PRAT pwr = nullptr;
@ -73,19 +73,19 @@ enum
FUNC_XOR FUNC_XOR
} BOOL_FUNCS; } BOOL_FUNCS;
void andrat(PRAT* pa, PRAT b, uint32_t radix, int32_t precision) void andrat(_Inout_ PRAT* pa, _In_ PRAT b, uint32_t radix, int32_t precision)
{ {
boolrat(pa, b, FUNC_AND, radix, precision); boolrat(pa, b, FUNC_AND, radix, precision);
} }
void orrat(PRAT* pa, PRAT b, uint32_t radix, int32_t precision) void orrat(_Inout_ PRAT* pa, _In_ PRAT b, uint32_t radix, int32_t precision)
{ {
boolrat(pa, b, FUNC_OR, radix, precision); boolrat(pa, b, FUNC_OR, radix, precision);
} }
void xorrat(PRAT* pa, PRAT b, uint32_t radix, int32_t precision) void xorrat(_Inout_ PRAT* pa, _In_ PRAT b, uint32_t radix, int32_t precision)
{ {
boolrat(pa, b, FUNC_XOR, radix, precision); boolrat(pa, b, FUNC_XOR, radix, precision);
@ -191,7 +191,7 @@ void boolnum(PNUMBER* pa, PNUMBER b, int func)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void remrat(PRAT* pa, PRAT b) void remrat(_Inout_ PRAT* pa, _In_ PRAT b)
{ {
if (zerrat(b)) if (zerrat(b))
@ -228,7 +228,7 @@ void remrat(PRAT* pa, PRAT b)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void modrat(PRAT* pa, PRAT b) void modrat(_Inout_ PRAT* pa, _In_ PRAT b)
{ {
// contrary to remrat(X, 0) returning 0, modrat(X, 0) must return X // contrary to remrat(X, 0) returning 0, modrat(X, 0) must return X
if (zerrat(b)) if (zerrat(b))

14
src/CalcManager/Ratpack/num.cpp
View File

@ -43,7 +43,7 @@ using namespace std;
void _addnum(PNUMBER* pa, PNUMBER b, uint32_t radix); void _addnum(PNUMBER* pa, PNUMBER b, uint32_t radix);
void addnum(PNUMBER* pa, PNUMBER b, uint32_t radix) void addnum(_Inout_ PNUMBER* pa, _In_ PNUMBER b, uint32_t radix)
{ {
if (b->cdigit > 1 || b->mant[0] != 0) if (b->cdigit > 1 || b->mant[0] != 0)
@ -186,7 +186,7 @@ void _addnum(PNUMBER* pa, PNUMBER b, uint32_t radix)
void _mulnum(PNUMBER* pa, PNUMBER b, uint32_t radix); void _mulnum(PNUMBER* pa, PNUMBER b, uint32_t radix);
void mulnum(PNUMBER* pa, PNUMBER b, uint32_t radix) void mulnum(_Inout_ PNUMBER* pa, _In_ PNUMBER b, uint32_t radix)
{ {
if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0) if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0)
@ -302,7 +302,7 @@ void _mulnum(PNUMBER* pa, PNUMBER b, uint32_t radix)
// //
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void remnum(PNUMBER* pa, PNUMBER b, uint32_t radix) void remnum(_Inout_ PNUMBER* pa, _In_ PNUMBER b, uint32_t radix)
{ {
PNUMBER tmp = nullptr; // tmp is the working remainder. PNUMBER tmp = nullptr; // tmp is the working remainder.
@ -365,7 +365,7 @@ void remnum(PNUMBER* pa, PNUMBER b, uint32_t radix)
void _divnum(PNUMBER* pa, PNUMBER b, uint32_t radix, int32_t precision); void _divnum(PNUMBER* pa, PNUMBER b, uint32_t radix, int32_t precision);
void divnum(PNUMBER* pa, PNUMBER b, uint32_t radix, int32_t precision) void divnum(_Inout_ PNUMBER* pa, _In_ PNUMBER b, uint32_t radix, int32_t precision)
{ {
if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0) if (b->cdigit > 1 || b->mant[0] != 1 || b->exp != 0)
@ -489,7 +489,7 @@ void _divnum(PNUMBER* pa, PNUMBER b, uint32_t radix, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool equnum(PNUMBER a, PNUMBER b) bool equnum(_In_ PNUMBER a, _In_ PNUMBER b)
{ {
int32_t diff; int32_t diff;
@ -555,7 +555,7 @@ bool equnum(PNUMBER a, PNUMBER b)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool lessnum(PNUMBER a, PNUMBER b) bool lessnum(_In_ PNUMBER a, _In_ PNUMBER b)
{ {
int32_t diff; int32_t diff;
@ -614,7 +614,7 @@ bool lessnum(PNUMBER a, PNUMBER b)
// //
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool zernum(PNUMBER a) bool zernum(_In_ PNUMBER a)
{ {
int32_t length; int32_t length;

16
src/CalcManager/Ratpack/rat.cpp
View File

@ -37,7 +37,7 @@ using namespace std;
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void gcdrat(PRAT* pa, int32_t precision) void gcdrat(_Inout_ PRAT* pa, int32_t precision)
{ {
PNUMBER pgcd = nullptr; PNUMBER pgcd = nullptr;
@ -70,7 +70,7 @@ void gcdrat(PRAT* pa, int32_t precision)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void fracrat(PRAT* pa, uint32_t radix, int32_t precision) void fracrat(_Inout_ PRAT* pa, uint32_t radix, int32_t precision)
{ {
// Only do the flatrat operation if number is nonzero. // Only do the flatrat operation if number is nonzero.
// and only if the bottom part is not one. // and only if the bottom part is not one.
@ -98,7 +98,7 @@ void fracrat(PRAT* pa, uint32_t radix, int32_t precision)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void mulrat(PRAT* pa, PRAT b, int32_t precision) void mulrat(_Inout_ PRAT* pa, _In_ PRAT b, int32_t precision)
{ {
// Only do the multiply if it isn't zero. // Only do the multiply if it isn't zero.
@ -132,7 +132,7 @@ void mulrat(PRAT* pa, PRAT b, int32_t precision)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void divrat(PRAT* pa, PRAT b, int32_t precision) void divrat(_Inout_ PRAT* pa, _In_ PRAT b, int32_t precision)
{ {
if (!zernum((*pa)->pp)) if (!zernum((*pa)->pp))
@ -182,7 +182,7 @@ void divrat(PRAT* pa, PRAT b, int32_t precision)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void subrat(PRAT* pa, PRAT b, int32_t precision) void subrat(_Inout_ PRAT* pa, _In_ PRAT b, int32_t precision)
{ {
b->pp->sign *= -1; b->pp->sign *= -1;
@ -203,7 +203,7 @@ void subrat(PRAT* pa, PRAT b, int32_t precision)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void addrat(PRAT* pa, PRAT b, int32_t precision) void addrat(_Inout_ PRAT* pa, _In_ PRAT b, int32_t precision)
{ {
PNUMBER bot = nullptr; PNUMBER bot = nullptr;
@ -255,7 +255,7 @@ void addrat(PRAT* pa, PRAT b, int32_t precision)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void rootrat(PRAT* py, PRAT n, uint32_t radix, int32_t precision) void rootrat(_Inout_ PRAT* py, _In_ PRAT n, uint32_t radix, int32_t precision)
{ {
// Initialize 1/n // Initialize 1/n
PRAT oneovern = nullptr; PRAT oneovern = nullptr;
@ -280,7 +280,7 @@ void rootrat(PRAT* py, PRAT n, uint32_t radix, int32_t precision)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
bool zerrat(PRAT a) bool zerrat(_In_ PRAT a)
{ {
return (zernum(a->pp)); return (zernum(a->pp));

6
src/CalcManager/Ratpack/ratpak.h
View File

@ -369,7 +369,7 @@ extern PNUMBER i32factnum(int32_t ini32, uint32_t radix);
extern PNUMBER i32prodnum(int32_t start, int32_t stop, uint32_t radix); extern PNUMBER i32prodnum(int32_t start, int32_t stop, uint32_t radix);
extern PNUMBER i32tonum(int32_t ini32, uint32_t radix); extern PNUMBER i32tonum(int32_t ini32, uint32_t radix);
extern PNUMBER Ui32tonum(uint32_t ini32, uint32_t radix); extern PNUMBER Ui32tonum(uint32_t ini32, uint32_t radix);
extern PNUMBER numtonRadixx(PNUMBER a, uint32_t radix); extern PNUMBER numtonRadixx(_In_ PNUMBER a, uint32_t radix);
// creates a empty/undefined rational representation (p/q) // creates a empty/undefined rational representation (p/q)
extern PRAT _createrat(void); extern PRAT _createrat(void);
@ -446,8 +446,8 @@ extern void tananglerat(_Inout_ PRAT* px, ANGLE_TYPE angletype, uint32_t radix,
extern void _dupnum(_In_ PNUMBER dest, _In_ const NUMBER* const src); extern void _dupnum(_In_ PNUMBER dest, _In_ const NUMBER* const src);
extern void _destroynum(_In_ PNUMBER pnum); extern void _destroynum(_Frees_ptr_opt_ PNUMBER pnum);
extern void _destroyrat(_In_ PRAT prat); extern void _destroyrat(_Frees_ptr_opt_ PRAT prat);
extern void addnum(_Inout_ PNUMBER* pa, _In_ PNUMBER b, uint32_t radix); extern void addnum(_Inout_ PNUMBER* pa, _In_ PNUMBER b, uint32_t radix);
extern void addrat(_Inout_ PRAT* pa, _In_ PRAT b, int32_t precision); extern void addrat(_Inout_ PRAT* pa, _In_ PRAT b, int32_t precision);
extern void andrat(_Inout_ PRAT* pa, _In_ PRAT b, uint32_t radix, int32_t precision); extern void andrat(_Inout_ PRAT* pa, _In_ PRAT b, uint32_t radix, int32_t precision);

26
src/CalcManager/Ratpack/support.cpp
View File

@ -296,7 +296,7 @@ void ChangeConstants(uint32_t radix, int32_t precision)
// //
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void intrat(PRAT* px, uint32_t radix, int32_t precision) void intrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
// Only do the intrat operation if number is nonzero. // Only do the intrat operation if number is nonzero.
// and only if the bottom part is not one. // and only if the bottom part is not one.
@ -328,7 +328,7 @@ void intrat(PRAT* px, uint32_t radix, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool rat_equ(PRAT a, PRAT b, int32_t precision) bool rat_equ(_In_ PRAT a, _In_ PRAT b, int32_t precision)
{ {
PRAT rattmp = nullptr; PRAT rattmp = nullptr;
@ -351,7 +351,7 @@ bool rat_equ(PRAT a, PRAT b, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool rat_ge(PRAT a, PRAT b, int32_t precision) bool rat_ge(_In_ PRAT a, _In_ PRAT b, int32_t precision)
{ {
PRAT rattmp = nullptr; PRAT rattmp = nullptr;
@ -375,7 +375,7 @@ bool rat_ge(PRAT a, PRAT b, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool rat_gt(PRAT a, PRAT b, int32_t precision) bool rat_gt(_In_ PRAT a, _In_ PRAT b, int32_t precision)
{ {
PRAT rattmp = nullptr; PRAT rattmp = nullptr;
@ -399,7 +399,7 @@ bool rat_gt(PRAT a, PRAT b, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool rat_le(PRAT a, PRAT b, int32_t precision) bool rat_le(_In_ PRAT a, _In_ PRAT b, int32_t precision)
{ {
PRAT rattmp = nullptr; PRAT rattmp = nullptr;
@ -423,7 +423,7 @@ bool rat_le(PRAT a, PRAT b, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool rat_lt(PRAT a, PRAT b, int32_t precision) bool rat_lt(_In_ PRAT a, _In_ PRAT b, int32_t precision)
{ {
PRAT rattmp = nullptr; PRAT rattmp = nullptr;
@ -447,7 +447,7 @@ bool rat_lt(PRAT a, PRAT b, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool rat_neq(PRAT a, PRAT b, int32_t precision) bool rat_neq(_In_ PRAT a, _In_ PRAT b, int32_t precision)
{ {
PRAT rattmp = nullptr; PRAT rattmp = nullptr;
@ -470,7 +470,7 @@ bool rat_neq(PRAT a, PRAT b, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void scale(PRAT* px, PRAT scalefact, uint32_t radix, int32_t precision) void scale(_Inout_ PRAT* px, _In_ PRAT scalefact, uint32_t radix, int32_t precision)
{ {
PRAT pret = nullptr; PRAT pret = nullptr;
DUPRAT(pret, *px); DUPRAT(pret, *px);
@ -503,7 +503,7 @@ void scale(PRAT* px, PRAT scalefact, uint32_t radix, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void scale2pi(PRAT* px, uint32_t radix, int32_t precision) void scale2pi(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
PRAT pret = nullptr; PRAT pret = nullptr;
PRAT my_two_pi = nullptr; PRAT my_two_pi = nullptr;
@ -546,7 +546,7 @@ void scale2pi(PRAT* px, uint32_t radix, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void inbetween(PRAT* px, PRAT range, int32_t precision) void inbetween(_In_ PRAT* px, _In_ PRAT range, int32_t precision)
{ {
if (rat_gt(*px, range, precision)) if (rat_gt(*px, range, precision))
@ -575,7 +575,7 @@ void inbetween(PRAT* px, PRAT range, int32_t precision)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void _dumprawrat(const wchar_t* varname, PRAT rat, wostream& out) void _dumprawrat(_In_ const wchar_t* varname, _In_ PRAT rat, wostream& out)
{ {
_dumprawnum(varname, rat->pp, out); _dumprawnum(varname, rat->pp, out);
@ -593,7 +593,7 @@ void _dumprawrat(const wchar_t* varname, PRAT rat, wostream& out)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void _dumprawnum(const wchar_t* varname, PNUMBER num, wostream& out) void _dumprawnum(_In_ const wchar_t* varname, _In_ PNUMBER num, wostream& out)
{ {
int i; int i;
@ -676,7 +676,7 @@ void _readconstants(void)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void trimit(PRAT* px, int32_t precision) void trimit(_Inout_ PRAT* px, int32_t precision)
{ {
if (!g_ftrueinfinite) if (!g_ftrueinfinite)

4
src/CalcManager/Ratpack/trans.cpp
View File

@ -187,7 +187,7 @@ void _cosrat(PRAT* px, uint32_t radix, int32_t precision)
} }
} }
void cosrat(PRAT* px, uint32_t radix, int32_t precision) void cosrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
scale2pi(px, radix, precision); scale2pi(px, radix, precision);
_cosrat(px, radix, precision); _cosrat(px, radix, precision);
@ -257,7 +257,7 @@ void _tanrat(PRAT* px, uint32_t radix, int32_t precision)
destroyrat(ptmp); destroyrat(ptmp);
} }
void tanrat(PRAT* px, uint32_t radix, int32_t precision) void tanrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
scale2pi(px, radix, precision); scale2pi(px, radix, precision);
_tanrat(px, radix, precision); _tanrat(px, radix, precision);

8
src/CalcManager/Ratpack/transh.cpp
View File

@ -1,4 +1,4 @@
// Copyright (c) Microsoft Corporation. All rights reserved. // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. // Licensed under the MIT License.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -88,7 +88,7 @@ void _sinhrat(PRAT* px, int32_t precision)
DESTROYTAYLOR(); DESTROYTAYLOR();
} }
void sinhrat(PRAT* px, uint32_t radix, int32_t precision) void sinhrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
PRAT tmpx = nullptr; PRAT tmpx = nullptr;
@ -169,7 +169,7 @@ void _coshrat(PRAT* px, uint32_t radix, int32_t precision)
DESTROYTAYLOR(); DESTROYTAYLOR();
} }
void coshrat(PRAT* px, uint32_t radix, int32_t precision) void coshrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
PRAT tmpx = nullptr; PRAT tmpx = nullptr;
@ -211,7 +211,7 @@ void coshrat(PRAT* px, uint32_t radix, int32_t precision)
// //
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void tanhrat(PRAT* px, uint32_t radix, int32_t precision) void tanhrat(_Inout_ PRAT* px, uint32_t radix, int32_t precision)
{ {
PRAT ptmp = nullptr; PRAT ptmp = nullptr;