From 71b3bbb7698b13b42c99a4ca66c27db4a6189ff8 Mon Sep 17 00:00:00 2001
From: Eugen Wissner <belka@caraus.de>
Date: Sat, 1 Aug 2026 16:05:51 +0200
Subject: Enforce integral values in slice ranges

---
 boot/evaluator.cc | 35 +++++++++++++++--------------------
 1 file changed, 15 insertions(+), 20 deletions(-)

(limited to 'boot/evaluator.cc')

diff --git a/boot/evaluator.cc b/boot/evaluator.cc
index 14b8ea3..56ba270 100644
--- a/boot/evaluator.cc
+++ b/boot/evaluator.cc
@@ -21,7 +21,6 @@ along with GCC; see the file COPYING3.  If not see
 
 #include <algorithm>
 #include <cstddef>
-#include <cstdint>
 #include <limits>
 #include <ranges>
 
@@ -212,27 +211,23 @@ namespace elna::boot
     {
         type const decoration = subject.type_decoration;
 
-        if (is_primitive_type(decoration, "Int"))
+        if (is_primitive_type(decoration, "Int") || is_primitive_type(decoration, "Word"))
         {
             return constant_value{ static_cast<literal<integer_literal>&>(subject).value };
         }
-        if (is_primitive_type(decoration, "Word"))
-        {
-            return constant_value{ static_cast<literal<integer_literal>&>(subject).value };
-        }
-        if (is_primitive_type(decoration, "Float"))
+        else if (is_primitive_type(decoration, "Float"))
         {
             return constant_value{ static_cast<literal<double>&>(subject).value };
         }
-        if (is_primitive_type(decoration, "Bool"))
+        else if (is_primitive_type(decoration, "Bool"))
         {
             return constant_value{ static_cast<literal<bool>&>(subject).value };
         }
-        if (is_primitive_type(decoration, "Char"))
+        else if (is_primitive_type(decoration, "Char"))
         {
             return constant_value{ static_cast<literal<unsigned char>&>(subject).value };
         }
-        if (is_primitive_type(decoration, "Pointer"))
+        else if (is_primitive_type(decoration, "Pointer"))
         {
             return constant_value{ std::nullptr_t{} };
         }
@@ -289,7 +284,7 @@ namespace elna::boot
             {
                 auto enumeration_position = std::distance(enumeration->members.begin(), member_iterator) + 1;
                 return constant_value{
-                    integer_literal::from(static_cast<std::int32_t>(enumeration_position))
+                    integer_literal::from(static_cast<std::size_t>(enumeration_position))
                 };
             }
             return std::nullopt;
@@ -704,14 +699,14 @@ namespace elna::boot
         {
             if (auto size = evaluate_traits_size(subject.types.front()))
             {
-                return constant_value{ integer_literal::from(static_cast<std::uint32_t>(size.value())) };
+                return constant_value{ integer_literal::from(size.value()) };
             }
         }
         else if (subject.name.name() == "alignment")
         {
             if (auto alignment = evaluate_traits_alignment(subject.types.front()))
             {
-                return constant_value{ integer_literal::from(static_cast<std::uint32_t>(alignment.value())) };
+                return constant_value{ integer_literal::from(alignment.value()) };
             }
         }
         else if (subject.name.name() == "min")
@@ -720,11 +715,11 @@ namespace elna::boot
 
             if (is_primitive_type(resolved, "Int"))
             {
-                return constant_value{ integer_literal::from(std::numeric_limits<std::int32_t>::min()) };
+                return constant_value{ integer_literal::from(std::numeric_limits<std::ptrdiff_t>::min()) };
             }
             if (is_primitive_type(resolved, "Word"))
             {
-                return constant_value{ integer_literal::from<std::uint32_t>(0) };
+                return constant_value{ integer_literal::from<std::size_t>(0) };
             }
             if (is_primitive_type(resolved, "Char"))
             {
@@ -740,7 +735,7 @@ namespace elna::boot
             }
             if (auto enumeration = resolved.get<enumeration_type>())
             {
-                return constant_value{ integer_literal::from<std::int32_t>(1) };
+                return constant_value{ integer_literal::from<std::size_t>(1) };
             }
         }
         else if (subject.name.name() == "max")
@@ -749,11 +744,11 @@ namespace elna::boot
 
             if (is_primitive_type(resolved, "Int"))
             {
-                return constant_value{ integer_literal::from(std::numeric_limits<std::int32_t>::max()) };
+                return constant_value{ integer_literal::from(std::numeric_limits<std::ptrdiff_t>::max()) };
             }
             if (is_primitive_type(resolved, "Word"))
             {
-                return constant_value{ integer_literal::from(std::numeric_limits<std::uint32_t>::max()) };
+                return constant_value{ integer_literal::from(std::numeric_limits<std::size_t>::max()) };
             }
             if (is_primitive_type(resolved, "Char"))
             {
@@ -769,7 +764,7 @@ namespace elna::boot
             }
             if (auto enumeration = resolved.get<enumeration_type>())
             {
-                return constant_value{ integer_literal::from(static_cast<std::int32_t>(enumeration->members.size())) };
+                return constant_value{ integer_literal::from(enumeration->members.size()) };
             }
         }
         else if (subject.name.name() == "offset")
@@ -786,7 +781,7 @@ namespace elna::boot
 
                 if (field_search != std::cend(record_layout.value().offset_map))
                 {
-                    return constant_value{ integer_literal::from(static_cast<std::uint32_t>(field_search->second)) };
+                    return constant_value{ integer_literal::from(field_search->second) };
                 }
             }
         }
-- 
cgit v1.2.3