piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-07-21 13:20:27 -06:00
Code Issues Packages Projects Releases Wiki Activity

InputCommon/ExpressionParser: Make ValidateArguments access existing

Browse Source 
members instead of passing arguments.
This commit is contained in:
Jordan Woyak
2025-01-28 19:23:52 -06:00
parent e4b464e727
commit 67b8100cd2
3 changed files with 55 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Source/Core/InputCommon/ControlReference/ExpressionParser.cpp
View File

@ -769,7 +769,8 @@ private:
} }
} }
const auto argument_validation = func->SetArguments(std::move(args)); func->SetArguments(std::move(args));
const auto argument_validation = func->ValidateArguments();
if (std::holds_alternative<FunctionExpression::ExpectedArguments>(argument_validation)) if (std::holds_alternative<FunctionExpression::ExpectedArguments>(argument_validation))
{ {

130
Source/Core/InputCommon/ControlReference/FunctionExpression.cpp
View File

@ -16,11 +16,10 @@ using FSec = std::chrono::duration<ControlState>;
class ToggleExpression : public FunctionExpression class ToggleExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
// Optional 2nd argument for clearing state: // Optional 2nd argument for clearing state:
if (args.size() == 1 || args.size() == 2) if (GetArgCount() == 1 || GetArgCount() == 2)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"toggle_state_input, [clear_state_input]"}; return ExpectedArguments{"toggle_state_input, [clear_state_input]"};
@ -56,10 +55,9 @@ private:
class NotExpression : public FunctionExpression class NotExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -73,10 +71,9 @@ private:
class AbsExpression final : public FunctionExpression class AbsExpression final : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -89,10 +86,9 @@ private:
class SinExpression : public FunctionExpression class SinExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -105,10 +101,9 @@ private:
class CosExpression : public FunctionExpression class CosExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -121,10 +116,9 @@ private:
class TanExpression : public FunctionExpression class TanExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -137,10 +131,9 @@ private:
class ASinExpression : public FunctionExpression class ASinExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -153,10 +146,9 @@ private:
class ACosExpression : public FunctionExpression class ACosExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -169,10 +161,9 @@ private:
class ATanExpression : public FunctionExpression class ATanExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -185,10 +176,9 @@ private:
class ATan2Expression : public FunctionExpression class ATan2Expression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 2) if (GetArgCount() == 2)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"y, x"}; return ExpectedArguments{"y, x"};
@ -204,10 +194,9 @@ private:
class SqrtExpression : public FunctionExpression class SqrtExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -220,10 +209,9 @@ private:
class PowExpression : public FunctionExpression class PowExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 2) if (GetArgCount() == 2)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"base, exponent"}; return ExpectedArguments{"base, exponent"};
@ -239,10 +227,9 @@ private:
class MinExpression : public FunctionExpression class MinExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 2) if (GetArgCount() == 2)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"a, b"}; return ExpectedArguments{"a, b"};
@ -258,10 +245,9 @@ private:
class MaxExpression : public FunctionExpression class MaxExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 2) if (GetArgCount() == 2)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"a, b"}; return ExpectedArguments{"a, b"};
@ -277,10 +263,9 @@ private:
class ClampExpression : public FunctionExpression class ClampExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 3) if (GetArgCount() == 3)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"value, min, max"}; return ExpectedArguments{"value, min, max"};
@ -296,10 +281,9 @@ private:
class TimerExpression : public FunctionExpression class TimerExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"seconds"}; return ExpectedArguments{"seconds"};
@ -339,10 +323,9 @@ private:
class IfExpression : public FunctionExpression class IfExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 3) if (GetArgCount() == 3)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"condition, true_expression, false_expression"}; return ExpectedArguments{"condition, true_expression, false_expression"};
@ -359,10 +342,9 @@ private:
class UnaryMinusExpression : public FunctionExpression class UnaryMinusExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -379,10 +361,9 @@ private:
class UnaryPlusExpression : public FunctionExpression class UnaryPlusExpression : public FunctionExpression
{ {
private: private:
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 1) if (GetArgCount() == 1)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"expression"}; return ExpectedArguments{"expression"};
@ -394,10 +375,9 @@ private:
// usage: deadzone(input, amount) // usage: deadzone(input, amount)
class DeadzoneExpression : public FunctionExpression class DeadzoneExpression : public FunctionExpression
{ {
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 2) if (GetArgCount() == 2)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"input, amount"}; return ExpectedArguments{"input, amount"};
@ -415,10 +395,9 @@ class DeadzoneExpression : public FunctionExpression
// seconds is seconds to change from 0.0 to 1.0 // seconds is seconds to change from 0.0 to 1.0
class SmoothExpression : public FunctionExpression class SmoothExpression : public FunctionExpression
{ {
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 2 || args.size() == 3) if (GetArgCount() == 2 || GetArgCount() == 3)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"input, seconds_up, seconds_down = seconds_up"}; return ExpectedArguments{"input, seconds_up, seconds_down = seconds_up"};
@ -459,10 +438,9 @@ private:
// usage: hold(input, seconds) // usage: hold(input, seconds)
class HoldExpression : public FunctionExpression class HoldExpression : public FunctionExpression
{ {
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 2) if (GetArgCount() == 2)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"input, seconds"}; return ExpectedArguments{"input, seconds"};
@ -498,10 +476,9 @@ private:
// usage: tap(input, seconds, taps=2) // usage: tap(input, seconds, taps=2)
class TapExpression : public FunctionExpression class TapExpression : public FunctionExpression
{ {
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 2 || args.size() == 3) if (GetArgCount() == 2 || GetArgCount() == 3)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"input, seconds, taps = 2"}; return ExpectedArguments{"input, seconds, taps = 2"};
@ -558,10 +535,9 @@ private:
// speed is max movement per second // speed is max movement per second
class RelativeExpression : public FunctionExpression class RelativeExpression : public FunctionExpression
{ {
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() >= 2 && args.size() <= 4) if (GetArgCount() >= 2 && GetArgCount() <= 4)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"input, speed, [max_abs_value, [shared_state]]"}; return ExpectedArguments{"input, speed, [max_abs_value, [shared_state]]"};
@ -617,10 +593,9 @@ private:
// usage: pulse(input, seconds) // usage: pulse(input, seconds)
class PulseExpression : public FunctionExpression class PulseExpression : public FunctionExpression
{ {
ArgumentValidation ArgumentValidation ValidateArguments() override
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) override
{ {
if (args.size() == 2) if (GetArgCount() == 2)
return ArgumentsAreValid{}; return ArgumentsAreValid{};
else else
return ExpectedArguments{"input, seconds"}; return ExpectedArguments{"input, seconds"};
@ -739,12 +714,9 @@ void FunctionExpression::UpdateReferences(ControlEnvironment& env)
arg->UpdateReferences(env); arg->UpdateReferences(env);
} }
FunctionExpression::ArgumentValidation void FunctionExpression::SetArguments(std::vector<std::unique_ptr<Expression>>&& args)
FunctionExpression::SetArguments(std::vector<std::unique_ptr<Expression>>&& args)
{ {
m_args = std::move(args); m_args = std::move(args);
return ValidateArguments(m_args);
} }
Expression& FunctionExpression::GetArg(u32 number) Expression& FunctionExpression::GetArg(u32 number)

6
Source/Core/InputCommon/ControlReference/FunctionExpression.h
View File

@ -33,14 +33,12 @@ public:
int CountNumControls() const override; int CountNumControls() const override;
void UpdateReferences(ControlEnvironment& env) override; void UpdateReferences(ControlEnvironment& env) override;
ArgumentValidation SetArguments(std::vector<std::unique_ptr<Expression>>&& args); void SetArguments(std::vector<std::unique_ptr<Expression>>&& args);
virtual ArgumentValidation ValidateArguments() = 0;
void SetValue(ControlState value) override; void SetValue(ControlState value) override;
protected: protected:
virtual ArgumentValidation
ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) = 0;
Expression& GetArg(u32 number); Expression& GetArg(u32 number);
const Expression& GetArg(u32 number) const; const Expression& GetArg(u32 number) const;
u32 GetArgCount() const; u32 GetArgCount() const;