Refactored definition of all custom tokens.

Dandielo · Dandielo · commit c3a2ba6802c6 · 2025-08-01T22:00:03.000+09:00
diff --git a/source/code/systems/input_action_system/private/input_action_dsl.cxx b/source/code/systems/input_action_system/private/input_action_dsl.cxx
@@ -52,47 +52,47 @@ namespace ice
 
     static constexpr ice::TokenInfo Constant_Tokens[]{
         { "action", TokenType::ASL_KW_Action },
-        { "active", ice::grammar::UCT_WhenActive },
-        { "activate", ice::grammar::UCT_StepActivate },
+        { "active", TokenType::ASL_OP_IsActive },
+        { "activate", TokenType::ASL_OP_Activate },
         //{ "accumulated", ice::grammar::UCT_ActionFlagAccumulated },
-        { "deactivate", ice::grammar::UCT_StepDeactivate },
-        { "and", ice::grammar::UCT_WhenAnd },
+        { "deactivate", TokenType::ASL_OP_Deactivate },
+        { "and", TokenType::ASL_KW_WhenAnd },
         { "axis1d", TokenType::ASL_NT_Axis1D },
         { "axis2d", TokenType::ASL_NT_Axis2D },
         { "axis3d", TokenType::ASL_NT_Axis3D },
-        { "bool", ice::grammar::UCT_ActionTypeBool },
-        { "button", ice::grammar::UCT_InputTypeButton },
-        { "inactive", ice::grammar::UCT_WhenInactive },
-        { "float1", ice::grammar::UCT_ActionTypeFloat1 },
-        { "float2", ice::grammar::UCT_ActionTypeFloat2 },
-        { "float3", ice::grammar::UCT_ActionTypeFloat3 },
+        { "button", TokenType::ASL_NT_Button },
+        { "inactive", TokenType::ASL_OP_IsInactive },
+        { "bool", TokenType::ASL_NT_Bool },
+        { "float1", TokenType::ASL_NT_Float1 },
+        { "float2", TokenType::ASL_NT_Float2 },
+        { "float3", TokenType::ASL_NT_Float3 },
         // { "gamepad", ice::grammar::UCT_InputBindingPad },
         // { "gctrl", ice::grammar::UCT_InputBindingPad },
         //{ "km", ice::grammar::UCT_InputBindingKeyboard },
-        { "kb", ice::grammar::UCT_InputBindingKeyboard },
+        { "kb", TokenType::ASL_KW_Keyboard },
         //{ "keymod", ice::grammar::UCT_InputBindingKeyboard },
-        { "key", ice::grammar::UCT_InputBindingKeyboard },
+        { "key", TokenType::ASL_KW_Keyboard },
         // { "keyboard", ice::grammar::UCT_InputBindingKeyboard },,
-        { "max", ice::grammar::UCT_ModifierOpMax },
-        { "min", ice::grammar::UCT_ModifierOpMin },
-        { "mouse", ice::grammar::UCT_InputBindingMouse },
-        { "mp", ice::grammar::UCT_InputBindingMouse },
-        { "gamepad", ice::grammar::UCT_InputBindingPad },
-        { "gp", ice::grammar::UCT_InputBindingPad },
+        { "max", TokenType::ASL_OP_Max },
+        { "min", TokenType::ASL_OP_Min },
+        { "mouse", TokenType::ASL_KW_Mouse },
+        { "mp", TokenType::ASL_KW_Mouse },
+        { "gamepad", TokenType::ASL_KW_Controller },
+        { "gp", TokenType::ASL_KW_Controller },
         { "layer", TokenType::ASL_KW_Layer },
-        { "object", ice::grammar::UCT_ActionTypeObject },
-        { "or", ice::grammar::UCT_WhenOr },
-        { "once", ice::grammar::UCT_ActionFlagOnce },
-        { "pressed", ice::grammar::UCT_WhenPressed },
-        { "released", ice::grammar::UCT_WhenReleased },
+        { "object", TokenType::ASL_NT_Object },
+        { "or", TokenType::ASL_KW_WhenOr },
+        { "once", TokenType::ASL_KWF_Once },
+        { "pressed", TokenType::ASL_OP_IsPressed },
+        { "released", TokenType::ASL_OP_IsReleased },
         { "source", TokenType::ASL_KW_Source },
-        { "toggled", ice::grammar::UCT_ActionFlagToggled },
-        { "toggle", ice::grammar::UCT_StepToggle },
-        { "when", ice::grammar::UCT_When },
-        { "reset", ice::grammar::UCT_StepReset },
-        { "series", ice::grammar::UCT_WhenFlagCheckSeries },
-        { "time", ice::grammar::UCT_StepTime },
-        { "mod", ice::grammar::UCT_Modifier },
+        { "toggled", TokenType::ASL_KWF_Toggled },
+        { "toggle", TokenType::ASL_OP_Toggle },
+        { "when", TokenType::ASL_KW_When },
+        { "reset", TokenType::ASL_OP_Reset },
+        { "series", TokenType::ASL_KWF_CheckSeries },
+        { "time", TokenType::ASL_OP_Time },
+        { "mod", TokenType::ASL_KW_Modifier },
     };
 
     //! \brief A default implementation of a tokenizer for Arctic language.
diff --git a/source/code/systems/input_action_system/private/input_action_dsl_grammar.hxx b/source/code/systems/input_action_system/private/input_action_dsl_grammar.hxx
@@ -27,9 +27,9 @@ namespace ice::grammar
     };
 
     static constexpr SyntaxRule Rule_LayerSourceBindingDeviceRules[]{
-        SyntaxRule{ UCT_InputBindingKeyboard },
-        SyntaxRule{ UCT_InputBindingMouse },
-        SyntaxRule{ UCT_InputBindingPad },
+        SyntaxRule{ TokenType::ASL_KW_Controller },
+        SyntaxRule{ TokenType::ASL_KW_Keyboard },
+        SyntaxRule{ TokenType::ASL_KW_Mouse },
     };
 
     static constexpr SyntaxRule Rule_LayerSourceBindingRules[]{ // ': <dev>.<src>' or ', <dev>.<src>'
@@ -40,7 +40,7 @@ namespace ice::grammar
     };
 
     static constexpr SyntaxRule Rule_LayerInputTypeRules[]{ // button, axis1d, axis2d or axis3d
-        SyntaxRule{ UCT_InputTypeButton },
+        SyntaxRule{ TokenType::ASL_NT_Button },
         SyntaxRule{ TokenType::ASL_NT_Axis1D },
         SyntaxRule{ TokenType::ASL_NT_Axis2D },
         SyntaxRule{ TokenType::ASL_NT_Axis3D },
@@ -98,11 +98,11 @@ namespace ice::grammar
     };
 
     static constexpr SyntaxRule Rule_LayerActionStepBuiltInListRules[]{
-        SyntaxRule{ UCT_StepActivate },
-        SyntaxRule{ UCT_StepDeactivate },
-        SyntaxRule{ UCT_StepToggle },
-        SyntaxRule{ UCT_StepReset },
-        SyntaxRule{ UCT_StepTime },
+        SyntaxRule{ TokenType::ASL_OP_Activate },
+        SyntaxRule{ TokenType::ASL_OP_Deactivate },
+        SyntaxRule{ TokenType::ASL_OP_Toggle },
+        SyntaxRule{ TokenType::ASL_OP_Reset },
+        SyntaxRule{ TokenType::ASL_OP_Time },
     };
 
     static constexpr SyntaxRule Rule_LayerActionStepArithmeticOperationRules[]{
@@ -152,10 +152,10 @@ namespace ice::grammar
     };
 
     static constexpr SyntaxRule Rule_LayerActionWhenTargetActionConditionListRules[]{
-        SyntaxRule{ UCT_WhenPressed },
-        SyntaxRule{ UCT_WhenReleased },
-        SyntaxRule{ UCT_WhenActive },
-        SyntaxRule{ UCT_WhenInactive },
+        SyntaxRule{ TokenType::ASL_OP_IsPressed },
+        SyntaxRule{ TokenType::ASL_OP_IsReleased },
+        SyntaxRule{ TokenType::ASL_OP_IsActive },
+        SyntaxRule{ TokenType::ASL_OP_IsInactive },
         SyntaxRule{ TokenType::KW_True },
     };
 
@@ -190,28 +190,27 @@ namespace ice::grammar
     };
 
     static constexpr SyntaxRule Rule_LayerActionWhenBlockRules[]{
-        SyntaxRule{ UCT_When },
-        SyntaxRule{ UCT_WhenAnd },
-        SyntaxRule{ UCT_WhenOr },
+        SyntaxRule{ TokenType::ASL_KW_When },
+        SyntaxRule{ TokenType::ASL_KW_WhenAnd },
+        SyntaxRule{ TokenType::ASL_KW_WhenOr },
     };
 
     static constexpr SyntaxRule Rule_LayerActionFlagsListRules[]{
-        SyntaxRule{ UCT_ActionFlagOnce, &syntax::LayerAction::flag_once },
-        SyntaxRule{ UCT_ActionFlagToggled, &syntax::LayerAction::flag_toggled },
-        //SyntaxRule{ UCT_ActionFlagAccumulated, &syntax::LayerAction::flag_accumulated },
+        SyntaxRule{ TokenType::ASL_KWF_Once, &syntax::LayerAction::flag_once },
+        SyntaxRule{ TokenType::ASL_KWF_Toggled, &syntax::LayerAction::flag_toggled },
     };
 
     static constexpr SyntaxRule Rule_LayerActionFlagsRules[]{
-        SyntaxRule{ grammar::TokenType::CT_Comma },
+        SyntaxRule{ TokenType::CT_Comma },
         SyntaxRule{ Rule_LayerActionFlagsListRules, MatchFirst }
     };
 
     static constexpr SyntaxRule Rule_LayerActionWhenFlagsListRules[]{
-        SyntaxRule{ UCT_WhenFlagCheckSeries, &syntax::LayerActionWhen::flag_series }
+        SyntaxRule{ TokenType::ASL_KWF_CheckSeries, &syntax::LayerActionWhen::flag_series }
     };
 
     static constexpr SyntaxRule Rule_LayerActionWhenFlagsRules[]{
-        SyntaxRule{ grammar::TokenType::CT_Comma },
+        SyntaxRule{ TokenType::CT_Comma },
         SyntaxRule{ Rule_LayerActionWhenFlagsListRules, MatchFirst }
     };
 
@@ -240,12 +239,12 @@ namespace ice::grammar
         SyntaxRule{ TokenType::OP_Mul },
         SyntaxRule{ TokenType::OP_Plus },
         SyntaxRule{ TokenType::OP_Minus },
-        SyntaxRule{ UCT_ModifierOpMin },
-        SyntaxRule{ UCT_ModifierOpMax },
+        SyntaxRule{ TokenType::ASL_OP_Min },
+        SyntaxRule{ TokenType::ASL_OP_Max },
     };
 
     static constexpr SyntaxRule Rule_LayerActionModifierRules[]{
-        SyntaxRule{ UCT_Modifier },
+        SyntaxRule{ TokenType::ASL_KW_Modifier },
         SyntaxRule{ Rule_LayerActionModifierComponentRules, MatchAll },
         SyntaxRule{ Rule_LayerActionModifierOperationListRules, MatchFirst, &syntax::LayerActionModifier::operation },
         SyntaxRule{ Rule_LayerActionWhenParamNumberTokenListRules, MatchFirst, &syntax::LayerActionModifier::param },
@@ -257,11 +256,11 @@ namespace ice::grammar
     ////////////////////////////////////////////////////////////////
 
     static constexpr SyntaxRule Rule_LayerActionTypeRules[]{ // button, axis1d, axis2d or axis3d
-        SyntaxRule{ UCT_ActionTypeBool },
-        SyntaxRule{ UCT_ActionTypeFloat1 },
-        SyntaxRule{ UCT_ActionTypeFloat2 },
-        SyntaxRule{ UCT_ActionTypeFloat3 },
-        SyntaxRule{ UCT_ActionTypeObject },
+        SyntaxRule{ TokenType::ASL_NT_Bool },
+        SyntaxRule{ TokenType::ASL_NT_Float1 },
+        SyntaxRule{ TokenType::ASL_NT_Float2 },
+        SyntaxRule{ TokenType::ASL_NT_Float3 },
+        SyntaxRule{ TokenType::ASL_NT_Object },
     };
 
     static constexpr SyntaxRule Rule_LayerActionRules[]{ // action <name>: <native_type>
diff --git a/source/code/systems/input_action_system/private/input_action_dsl_layer_builder.cxx b/source/code/systems/input_action_system/private/input_action_dsl_layer_builder.cxx
@@ -57,9 +57,10 @@ namespace ice
         ice::InputActionSourceType type = InputActionSourceType::Key;
         switch(node.data().type.type)
         {
-        case ice::grammar::UCT_InputTypeButton: type = InputActionSourceType::Button; break;
+        case TokenType::ASL_NT_Button: type = InputActionSourceType::Button; break;
         case TokenType::ASL_NT_Axis1D: type = InputActionSourceType::Axis1d; break;
         case TokenType::ASL_NT_Axis2D: type = InputActionSourceType::Axis2d; break;
+        default: ICE_ASSERT_CORE(false); type = InputActionSourceType::Axis2d; break;
         }
 
         ice::InputActionBuilder::Source source = _builder->define_source(node.data().name, type);
@@ -71,25 +72,15 @@ namespace ice
             using ice::input::KeyboardMod;
             using ice::input::MouseInput;
 
-            if (binding.data().device.type == ice::grammar::UCT_InputBindingKeyboard)
+            if (binding.data().device.type == TokenType::ASL_KW_Keyboard)
             {
                 ICE_ASSERT_CORE(type == InputActionSourceType::Key || type == InputActionSourceType::Button);
 
-                //ice::u64 const valsize = binding.data().device.value.size();
-                //if (binding.data().device.value[valsize / 2] == 'm')
-                //{
-                //    KeyboardMod const mod = detail::mod_from_dsl(binding.data().source);
-                //    ICE_ASSERT_CORE(mod != KeyboardMod::None);
-                //    source.add_keymod(mod);
-                //}
-                //else
-                {
-                    KeyboardKey const key = detail::key_from_dsl(binding.data().source);
-                    ICE_ASSERT_CORE(key != KeyboardKey::Unknown);
-                    source.add_key(key);
-                }
+                KeyboardKey const key = detail::key_from_dsl(binding.data().source);
+                ICE_ASSERT_CORE(key != KeyboardKey::Unknown);
+                source.add_key(key);
             }
-            else if (binding.data().device.type == ice::grammar::UCT_InputBindingMouse)
+            else if (binding.data().device.type == TokenType::ASL_KW_Mouse)
             {
                 MouseInput const mouseinput = detail::mouse_from_dsl(binding.data().source);
                 ICE_ASSERT_CORE(
@@ -160,7 +151,7 @@ namespace ice
         using enum ice::InputActionCondition;
 
         arctic::SyntaxNode<ice::syntax::LayerActionWhen> cond_node = node;
-        ICE_ASSERT_CORE(cond_node.data().type.type == grammar::UCT_When);
+        ICE_ASSERT_CORE(cond_node.data().type.type == TokenType::ASL_KW_When);
 
         ICE_LOG(LogSeverity::Debug, LogTag::Tool, "New condition series");
         do
@@ -183,7 +174,7 @@ namespace ice
                 flags |= InputActionConditionFlags::SeriesCheck;
             }
 
-            if (cond.type.type == grammar::UCT_WhenAnd)
+            if (cond.type.type == TokenType::ASL_KW_WhenAnd)
             {
                 flags |= InputActionConditionFlags::SeriesAnd;
             }
@@ -219,7 +210,7 @@ namespace ice
             }
 
             cond_node = cond_node.sibling<ice::syntax::LayerActionWhen>();
-        } while (cond_node && cond_node.data().type.type != grammar::UCT_When);
+        } while (cond_node && cond_node.data().type.type != TokenType::ASL_KW_When);
 
         // TODO: Check for '.continue' flag to skip setting 'Final' flag here
         //if (/* DOES NOT HAVE '.continue' flag */)
@@ -379,10 +370,10 @@ namespace ice
         switch (token.type)
         {
             // Action conditions
-        case grammar::UCT_ActionTypeBool: return InputActionDataType::Bool;
-        case grammar::UCT_ActionTypeFloat1: return InputActionDataType::Float1;
-        case grammar::UCT_ActionTypeFloat2: return InputActionDataType::Float2;
-        case grammar::UCT_ActionTypeObject: return InputActionDataType::ActionObject;
+        case TokenType::ASL_NT_Bool: return InputActionDataType::Bool;
+        case TokenType::ASL_NT_Float1: return InputActionDataType::Float1;
+        case TokenType::ASL_NT_Float2: return InputActionDataType::Float2;
+        case TokenType::ASL_NT_Object: return InputActionDataType::ActionObject;
         default: ICE_ASSERT_CORE(false); return InputActionDataType::Invalid;
         }
     }
@@ -392,19 +383,19 @@ namespace ice
         switch(token.type)
         {
             // Action conditions
-        case grammar::UCT_WhenPressed: return InputActionCondition::Pressed;
-        case grammar::UCT_WhenReleased: return InputActionCondition::Released;
-        case grammar::UCT_WhenActive: return action_condition ? InputActionCondition::ActionToggleActive : InputActionCondition::Active;
-        case grammar::UCT_WhenInactive: return InputActionCondition::ActionToggleInactive;
+        case TokenType::ASL_OP_IsPressed: return InputActionCondition::Pressed;
+        case TokenType::ASL_OP_IsReleased: return InputActionCondition::Released;
+        case TokenType::ASL_OP_IsActive: return action_condition ? InputActionCondition::ActionToggleActive : InputActionCondition::Active;
+        case TokenType::ASL_OP_IsInactive: return InputActionCondition::ActionToggleInactive;
             // Arithmetic conditions
-        case arctic::TokenType::OP_Equal: return InputActionCondition::Equal;
-        case arctic::TokenType::OP_NotEqual: return InputActionCondition::NotEqual; // TODO
-        case arctic::TokenType::OP_Greater: return InputActionCondition::Greater;
-        case arctic::TokenType::OP_GreaterOrEqual: return InputActionCondition::GreaterOrEqual;
-        case arctic::TokenType::OP_Less: return InputActionCondition::Lower;
-        case arctic::TokenType::OP_LessOrEqual: return InputActionCondition::LowerOrEqual;
+        case TokenType::OP_Equal: return InputActionCondition::Equal;
+        case TokenType::OP_NotEqual: return InputActionCondition::NotEqual; // TODO
+        case TokenType::OP_Greater: return InputActionCondition::Greater;
+        case TokenType::OP_GreaterOrEqual: return InputActionCondition::GreaterOrEqual;
+        case TokenType::OP_Less: return InputActionCondition::Lower;
+        case TokenType::OP_LessOrEqual: return InputActionCondition::LowerOrEqual;
             // Special conditions
-        case arctic::TokenType::KW_True: return InputActionCondition::AlwaysTrue;
+        case TokenType::KW_True: return InputActionCondition::AlwaysTrue;
         default: ICE_ASSERT_CORE(false); return InputActionCondition::Invalid;
         }
     }
@@ -413,15 +404,15 @@ namespace ice
     {
         switch(token.type)
         {
-        case grammar::UCT_StepActivate: return InputActionStep::Activate;
-        case grammar::UCT_StepDeactivate: return InputActionStep::Deactivate;
-        case grammar::UCT_StepToggle: return InputActionStep::Toggle;
-        case grammar::UCT_StepReset: return InputActionStep::Reset;
-        case grammar::UCT_StepTime: return InputActionStep::Time;
+        case TokenType::ASL_OP_Activate: return InputActionStep::Activate;
+        case TokenType::ASL_OP_Deactivate: return InputActionStep::Deactivate;
+        case TokenType::ASL_OP_Toggle: return InputActionStep::Toggle;
+        case TokenType::ASL_OP_Reset: return InputActionStep::Reset;
+        case TokenType::ASL_OP_Time: return InputActionStep::Time;
             // Arithmetic steps
-        case arctic::TokenType::OP_Assign: return InputActionStep::Set;
-        case arctic::TokenType::OP_Plus: return InputActionStep::Add;
-        case arctic::TokenType::OP_Minus: return InputActionStep::Sub;
+        case TokenType::OP_Assign: return InputActionStep::Set;
+        case TokenType::OP_Plus: return InputActionStep::Add;
+        case TokenType::OP_Minus: return InputActionStep::Sub;
         default: ICE_ASSERT_CORE(false); break;
         }
         return InputActionStep::Invalid;
@@ -431,13 +422,13 @@ namespace ice
     {
         switch (token.type)
         {
-        case grammar::UCT_ModifierOpMax: return InputActionModifier::Max;
-        case arctic::TokenType::OP_Div: return InputActionModifier::Div;
+        case TokenType::ASL_OP_Max: return InputActionModifier::Max;
+        case TokenType::OP_Div: return InputActionModifier::Div;
             // Not implemented yet
-        case grammar::UCT_ModifierOpMin:
-        case arctic::TokenType::OP_Mul:
-        case arctic::TokenType::OP_Plus:
-        case arctic::TokenType::OP_Minus:
+        case TokenType::ASL_OP_Min:
+        case TokenType::OP_Mul:
+        case TokenType::OP_Plus:
+        case TokenType::OP_Minus:
         default: ICE_ASSERT_CORE("Not Implemented!" && false); return InputActionModifier::Invalid;
         }
     }
diff --git a/source/code/systems/input_action_system/private/input_action_script_tokens.hxx b/source/code/systems/input_action_system/private/input_action_script_tokens.hxx
