diff --git a/Source/Core/DolphinQt/Config/Mapping/IOWindow.h b/Source/Core/DolphinQt/Config/Mapping/IOWindow.h
@@ -6,6 +6,7 @@
 
 #include <QDialog>
 #include <QString>
+#include <QSyntaxHighlighter>
 
 #include "Common/Flag.h"
 #include "InputCommon/ControllerInterface/Device.h"
@@ -14,6 +15,7 @@ class ControlReference;
 class QAbstractButton;
 class QComboBox;
 class QDialogButtonBox;
+class QLineEdit;
 class QListWidget;
 class QVBoxLayout;
 class QWidget;
@@ -27,6 +29,19 @@ namespace ControllerEmu
 class EmulatedController;
 }
 
+class ControlExpressionSyntaxHighlighter final : public QSyntaxHighlighter
+{
+  Q_OBJECT
+public:
+  ControlExpressionSyntaxHighlighter(QTextDocument* parent, QLineEdit* result);
+
+protected:
+  void highlightBlock(const QString& text) final override;
+
+private:
+  QLineEdit* const m_result_text;
+};
+
 class IOWindow final : public QDialog
 {
   Q_OBJECT
@@ -51,7 +66,7 @@ class IOWindow final : public QDialog
   void OnTestButtonPressed();
   void OnRangeChanged(int range);
 
-  void AppendSelectedOption(const std::string& prefix);
+  void AppendSelectedOption();
   void UpdateOptionList();
   void UpdateDeviceList();
 
@@ -70,19 +85,18 @@ class IOWindow final : public QDialog
 
   // Shared actions
   QPushButton* m_select_button;
-  QPushButton* m_or_button;
+  QComboBox* m_operators_combo;
 
   // Input actions
   QPushButton* m_detect_button;
-  QPushButton* m_and_button;
-  QPushButton* m_not_button;
-  QPushButton* m_add_button;
+  QComboBox* m_functions_combo;
 
   // Output actions
   QPushButton* m_test_button;
 
   // Textarea
   QPlainTextEdit* m_expression_text;
+  QLineEdit* m_parse_text;
 
   // Buttonbox
   QDialogButtonBox* m_button_box;

diff --git a/Source/Core/DolphinQt/Config/Mapping/MappingButton.cpp b/Source/Core/DolphinQt/Config/Mapping/MappingButton.cpp
@@ -100,7 +100,7 @@ void MappingButton::Detect()
     return;
 
   m_reference->SetExpression(expression.toStdString());
-  m_parent->GetController()->UpdateReferences(g_controller_interface);
+  m_parent->GetController()->UpdateSingleControlReference(g_controller_interface, m_reference);
 
   ConfigChanged();
   m_parent->SaveSettings();
@@ -111,7 +111,7 @@ void MappingButton::Clear()
   m_reference->range = 100.0 / SLIDER_TICK_COUNT;
 
   m_reference->SetExpression("");
-  m_parent->GetController()->UpdateReferences(g_controller_interface);
+  m_parent->GetController()->UpdateSingleControlReference(g_controller_interface, m_reference);
 
   m_parent->SaveSettings();
   ConfigChanged();

diff --git a/Source/Core/InputCommon/CMakeLists.txt b/Source/Core/InputCommon/CMakeLists.txt
@@ -45,6 +45,8 @@ add_library(inputcommon
   ControlReference/ControlReference.h
   ControlReference/ExpressionParser.cpp
   ControlReference/ExpressionParser.h
+  ControlReference/FunctionExpression.cpp
+  ControlReference/FunctionExpression.h
 )
 
 target_link_libraries(inputcommon PUBLIC

diff --git a/Source/Core/InputCommon/ControlReference/ControlReference.cpp b/Source/Core/InputCommon/ControlReference/ControlReference.cpp
@@ -25,12 +25,12 @@ bool ControlReference::InputGateOn()
 // Updates a controlreference's binded devices/controls
 // need to call this to re-bind a control reference after changing its expression
 //
-void ControlReference::UpdateReference(const ciface::Core::DeviceContainer& devices,
-                                       const ciface::Core::DeviceQualifier& default_device)
+void ControlReference::UpdateReference(ciface::ExpressionParser::ControlEnvironment& env)
 {
-  ControlFinder finder(devices, default_device, IsInput());
   if (m_parsed_expression)
-    m_parsed_expression->UpdateReferences(finder);
+  {
+    m_parsed_expression->UpdateReferences(env);
+  }
 }
 
 int ControlReference::BoundCount() const
@@ -54,7 +54,9 @@ std::string ControlReference::GetExpression() const
 void ControlReference::SetExpression(std::string expr)
 {
   m_expression = std::move(expr);
-  std::tie(m_parse_status, m_parsed_expression) = ParseExpression(m_expression);
+  auto parse_result = ParseExpression(m_expression);
+  m_parse_status = parse_result.status;
+  m_parsed_expression = std::move(parse_result.expr);
 }
 
 ControlReference::ControlReference() : range(1), m_parsed_expression(nullptr)

diff --git a/Source/Core/InputCommon/ControlReference/ControlReference.h b/Source/Core/InputCommon/ControlReference/ControlReference.h
@@ -30,8 +30,7 @@ class ControlReference
 
   int BoundCount() const;
   ciface::ExpressionParser::ParseStatus GetParseStatus() const;
-  void UpdateReference(const ciface::Core::DeviceContainer& devices,
-                       const ciface::Core::DeviceQualifier& default_device);
+  void UpdateReference(ciface::ExpressionParser::ControlEnvironment& env);
   std::string GetExpression() const;
   void SetExpression(std::string expr);
 

diff --git a/Source/Core/InputCommon/ControlReference/ExpressionParser.cpp b/Source/Core/InputCommon/ControlReference/ExpressionParser.cpp
diff --git a/Source/Core/InputCommon/ControlReference/ExpressionParser.h b/Source/Core/InputCommon/ControlReference/ExpressionParser.h
@@ -4,13 +4,102 @@
 
 #pragma once
 
+#include <map>
 #include <memory>
+#include <optional>
 #include <string>
-#include <utility>
+
 #include "InputCommon/ControllerInterface/Device.h"
 
 namespace ciface::ExpressionParser
 {
+enum TokenType
+{
+  TOK_WHITESPACE,
+  TOK_INVALID,
+  TOK_EOF,
+  TOK_LPAREN,
+  TOK_RPAREN,
+  TOK_NOT,
+  TOK_CONTROL,
+  TOK_LITERAL,
+  TOK_VARIABLE,
+  TOK_BAREWORD,
+  TOK_COMMENT,
+  // Binary Ops:
+  TOK_BINARY_OPS_BEGIN,
+  TOK_AND = TOK_BINARY_OPS_BEGIN,
+  TOK_OR,
+  TOK_ADD,
+  TOK_SUB,
+  TOK_MUL,
+  TOK_DIV,
+  TOK_MOD,
+  TOK_ASSIGN,
+  TOK_LTHAN,
+  TOK_GTHAN,
+  TOK_COMMA,
+  TOK_BINARY_OPS_END,
+};
+
+class Token
+{
+public:
+  TokenType type;
+  std::string data;
+
+  // Position in the input string:
+  std::size_t string_position = 0;
+  std::size_t string_length = 0;
+
+  explicit Token(TokenType type_);
+  Token(TokenType type_, std::string data_);
+
+  bool IsBinaryOperator() const;
+};
+
+enum class ParseStatus
+{
+  Successful,
+  SyntaxError,
+  EmptyExpression,
+};
+
+class Lexer
+{
+public:
+  std::string expr;
+  std::string::iterator it;
+
+  explicit Lexer(std::string expr_);
+
+  ParseStatus Tokenize(std::vector<Token>& tokens);
+
+private:
+  template <typename F>
+  std::string FetchCharsWhile(F&& func)
+  {
+    std::string value;
+    while (it != expr.end() && func(*it))
+    {
+      value += *it;
+      ++it;
+    }
+    return value;
+  }
+
+  std::string FetchDelimString(char delim);
+  std::string FetchWordChars();
+  Token GetDelimitedLiteral();
+  Token GetVariable();
+  Token GetFullyQualifiedControl();
+  Token GetBareword(char c);
+  Token GetRealLiteral(char c);
+
+  Token PeekToken();
+  Token NextToken();
+};
+
 class ControlQualifier
 {
 public:
@@ -19,30 +108,53 @@ class ControlQualifier
   std::string control_name;
 
   ControlQualifier() : has_device(false) {}
+
   operator std::string() const
   {
     if (has_device)
       return device_qualifier.ToString() + ":" + control_name;
     else
       return control_name;
   }
+
+  void FromString(const std::string& str)
+  {
+    const auto col_pos = str.find_last_of(':');
+
+    has_device = (str.npos != col_pos);
+    if (has_device)
+    {
+      device_qualifier.FromString(str.substr(0, col_pos));
+      control_name = str.substr(col_pos + 1);
+    }
+    else
+    {
+      device_qualifier.FromString("");
+      control_name = str;
+    }
+  }
 };
 
-class ControlFinder
+class ControlEnvironment
 {
 public:
-  ControlFinder(const Core::DeviceContainer& container_, const Core::DeviceQualifier& default_,
-                const bool is_input_)
-      : container(container_), default_device(default_), is_input(is_input_)
+  using VariableContainer = std::map<std::string, ControlState>;
+
+  ControlEnvironment(const Core::DeviceContainer& container_, const Core::DeviceQualifier& default_,
+                     VariableContainer& vars)
+      : m_variables(vars), container(container_), default_device(default_)
   {
   }
+
   std::shared_ptr<Core::Device> FindDevice(ControlQualifier qualifier) const;
-  Core::Device::Control* FindControl(ControlQualifier qualifier) const;
+  Core::Device::Input* FindInput(ControlQualifier qualifier) const;
+  Core::Device::Output* FindOutput(ControlQualifier qualifier) const;
+  ControlState* GetVariablePtr(const std::string& name);
 
 private:
+  VariableContainer& m_variables;
   const Core::DeviceContainer& container;
   const Core::DeviceQualifier& default_device;
-  bool is_input;
 };
 
 class Expression
@@ -52,16 +164,30 @@ class Expression
   virtual ControlState GetValue() const = 0;
   virtual void SetValue(ControlState state) = 0;
   virtual int CountNumControls() const = 0;
-  virtual void UpdateReferences(ControlFinder& finder) = 0;
-  virtual operator std::string() const = 0;
+  virtual void UpdateReferences(ControlEnvironment& finder) = 0;
 };
 
-enum class ParseStatus
+class ParseResult
 {
-  Successful,
-  SyntaxError,
-  EmptyExpression,
+public:
+  static ParseResult MakeEmptyResult();
+  static ParseResult MakeSuccessfulResult(std::unique_ptr<Expression>&& expr);
+  static ParseResult MakeErrorResult(Token token, std::string description);
+
+  ParseStatus status;
+  std::unique_ptr<Expression> expr;
+
+  // Used for parse errors:
+  // TODO: This should probably be moved elsewhere:
+  std::optional<Token> token;
+  std::optional<std::string> description;
+
+private:
+  ParseResult() = default;
 };
 
-std::pair<ParseStatus, std::unique_ptr<Expression>> ParseExpression(const std::string& expr);
+ParseResult ParseExpression(const std::string& expr);
+ParseResult ParseTokens(const std::vector<Token>& tokens);
+void RemoveInertTokens(std::vector<Token>* tokens);
+
 }  // namespace ciface::ExpressionParser
diff --git a/Source/Core/InputCommon/ControlReference/FunctionExpression.cpp b/Source/Core/InputCommon/ControlReference/FunctionExpression.cpp
diff --git a/Source/Core/InputCommon/ControlReference/FunctionExpression.h b/Source/Core/InputCommon/ControlReference/FunctionExpression.h
@@ -0,0 +1,55 @@
+// Copyright 2019 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "InputCommon/ControlReference/ExpressionParser.h"
+#include "InputCommon/ControlReference/FunctionExpression.h"
+
+namespace ciface
+{
+namespace ExpressionParser
+{
+class FunctionExpression : public Expression
+{
+public:
+  struct ArgumentsAreValid
+  {
+  };
+
+  struct ExpectedArguments
+  {
+    std::string text;
+  };
+
+  using ArgumentValidation = std::variant<ArgumentsAreValid, ExpectedArguments>;
+
+  int CountNumControls() const override;
+  void UpdateReferences(ControlEnvironment& env) override;
+
+  ArgumentValidation SetArguments(std::vector<std::unique_ptr<Expression>>&& args);
+
+  void SetValue(ControlState value) override;
+
+protected:
+  virtual ArgumentValidation
+  ValidateArguments(const std::vector<std::unique_ptr<Expression>>& args) = 0;
+
+  Expression& GetArg(u32 number);
+  const Expression& GetArg(u32 number) const;
+  u32 GetArgCount() const;
+
+private:
+  std::vector<std::unique_ptr<Expression>> m_args;
+};
+
+std::unique_ptr<FunctionExpression> MakeFunctionExpression(std::string name);
+
+}  // namespace ExpressionParser
+}  // namespace ciface
diff --git a/Source/Core/InputCommon/ControllerEmu/ControllerEmu.cpp b/Source/Core/InputCommon/ControllerEmu/ControllerEmu.cpp
@@ -38,23 +38,38 @@ std::unique_lock<std::recursive_mutex> EmulatedController::GetStateLock()
 
 void EmulatedController::UpdateReferences(const ControllerInterface& devi)
 {
-  const auto lock = GetStateLock();
   m_default_device_is_connected = devi.HasConnectedDevice(m_default_device);
 
+  ciface::ExpressionParser::ControlEnvironment env(devi, GetDefaultDevice(), m_expression_vars);
+
+  UpdateReferences(env);
+}
+
+void EmulatedController::UpdateReferences(ciface::ExpressionParser::ControlEnvironment& env)
+{
+  const auto lock = GetStateLock();
+
   for (auto& ctrlGroup : groups)
   {
     for (auto& control : ctrlGroup->controls)
-      control->control_ref.get()->UpdateReference(devi, GetDefaultDevice());
+      control->control_ref->UpdateReference(env);
 
     // Attachments:
     if (ctrlGroup->type == GroupType::Attachments)
     {
       for (auto& attachment : static_cast<Attachments*>(ctrlGroup.get())->GetAttachmentList())
-        attachment->UpdateReferences(devi);
+        attachment->UpdateReferences(env);
     }
   }
 }
 
+void EmulatedController::UpdateSingleControlReference(const ControllerInterface& devi,
+                                                      ControlReference* ref)
+{
+  ciface::ExpressionParser::ControlEnvironment env(devi, GetDefaultDevice(), m_expression_vars);
+  ref->UpdateReference(env);
+}
+
 bool EmulatedController::IsDefaultDeviceConnected() const
 {
   return m_default_device_is_connected;

diff --git a/Source/Core/InputCommon/ControllerEmu/ControllerEmu.h b/Source/Core/InputCommon/ControllerEmu/ControllerEmu.h
@@ -13,13 +13,16 @@
 
 #include "Common/Common.h"
 #include "Common/IniFile.h"
+#include "InputCommon/ControlReference/ExpressionParser.h"
 #include "InputCommon/ControllerInterface/Device.h"
 
 class ControllerInterface;
 
 const char* const named_directions[] = {_trans("Up"), _trans("Down"), _trans("Left"),
                                         _trans("Right")};
 
+class ControlReference;
+
 namespace ControllerEmu
 {
 class ControlGroup;
@@ -43,6 +46,7 @@ class EmulatedController
   void SetDefaultDevice(ciface::Core::DeviceQualifier devq);
 
   void UpdateReferences(const ControllerInterface& devi);
+  void UpdateSingleControlReference(const ControllerInterface& devi, ControlReference* ref);
 
   // This returns a lock that should be held before calling State() on any control
   // references and GetState(), by extension. This prevents a race condition
@@ -75,6 +79,12 @@ class EmulatedController
       return T(std::lround((zero_value - neg_1_value) * input_value + zero_value));
   }
 
+protected:
+  // TODO: Wiimote attachment has its own member that isn't being used..
+  ciface::ExpressionParser::ControlEnvironment::VariableContainer m_expression_vars;
+
+  void UpdateReferences(ciface::ExpressionParser::ControlEnvironment& env);
+
 private:
   ciface::Core::DeviceQualifier m_default_device;
   bool m_default_device_is_connected{false};

diff --git a/Source/Core/InputCommon/InputCommon.vcxproj b/Source/Core/InputCommon/InputCommon.vcxproj
@@ -64,6 +64,7 @@
     <ClCompile Include="ControllerInterface\ForceFeedback\ForceFeedbackDevice.cpp" />
     <ClCompile Include="ControllerInterface\Win32\Win32.cpp" />
     <ClCompile Include="ControllerInterface\XInput\XInput.cpp" />
+    <ClCompile Include="ControlReference\FunctionExpression.cpp" />
     <ClCompile Include="GCAdapter.cpp">
       <!--
       Disable "nonstandard extension used : zero-sized array in struct/union" warning,
@@ -100,6 +101,7 @@
     <ClInclude Include="ControllerInterface\DInput\DInputKeyboardMouse.h" />
     <ClInclude Include="ControllerInterface\DInput\XInputFilter.h" />
     <ClInclude Include="ControlReference\ControlReference.h" />
+    <ClInclude Include="ControlReference\FunctionExpression.h" />
     <ClInclude Include="ControlReference\ExpressionParser.h" />
     <ClInclude Include="ControllerInterface\ForceFeedback\ForceFeedbackDevice.h" />
     <ClInclude Include="ControllerInterface\Win32\Win32.h" />

diff --git a/Source/Core/InputCommon/InputCommon.vcxproj.filters b/Source/Core/InputCommon/InputCommon.vcxproj.filters
@@ -113,6 +113,9 @@
     <ClCompile Include="ControlReference\ControlReference.cpp">
       <Filter>ControllerInterface</Filter>
     </ClCompile>
+    <ClCompile Include="ControlReference\FunctionExpression.cpp">
+      <Filter>ControllerInterface</Filter>
+    </ClCompile>
     <ClCompile Include="InputProfile.cpp" />
     <ClCompile Include="ControllerEmu\ControlGroup\Attachments.cpp">
       <Filter>ControllerEmu\ControlGroup</Filter>
@@ -206,6 +209,9 @@
     <ClInclude Include="ControlReference\ControlReference.h">
       <Filter>ControllerInterface</Filter>
     </ClInclude>
+    <ClCompile Include="ControlReference\FunctionExpression.h">
+      <Filter>ControllerInterface</Filter>
+    </ClCompile>
     <ClInclude Include="InputProfile.h" />
     <ClInclude Include="ControllerEmu\ControlGroup\Attachments.h">
       <Filter>ControllerEmu\ControlGroup</Filter>