Implement fixed-size integers

28 files changed, 957 insertions, 247 deletions

diff --git a/boot/dependency.cc b/boot/dependency.cc
index 9ab5141..bd1251a 100644
--- a/boot/dependency.cc
+++ b/boot/dependency.cc
@@ -18,6 +18,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "elna/boot/dependency.h"
 
 #include "elna/boot/driver.h"
+#include "elna/boot/materialization.h"
 #include "elna/boot/name_analysis.h"
 #include "elna/boot/type_check.h"
 #include "elna/boot/validation.h"
@@ -25,7 +26,7 @@ along with GCC; see the file COPYING3.  If not see
 
 namespace elna::boot
 {
-    dependency read_source(std::istream& entry_point)
+    dependency read_source(std::istream& entry_point, const target_info& target)
     {
         driver parse_driver;
         lexer tokenizer(entry_point);
@@ -41,10 +42,18 @@ namespace elna::boot
         {
             std::swap(outcome.tree, parse_driver.tree);
         }
-        declaration_visitor declaration_visitor;
+        materialization_visitor materialization_visitor(target);
+        outcome.tree->accept(&materialization_visitor);
+
+        if (materialization_visitor.has_errors())
+        {
+            std::swap(outcome.errors(), materialization_visitor.errors());
+            return outcome;
+        }
+        declaration_visitor declaration_visitor{};
         outcome.tree->accept(&declaration_visitor);
 
-        if (!declaration_visitor.errors().empty())
+        if (declaration_visitor.has_errors())
         {
             std::swap(outcome.errors(), declaration_visitor.errors());
         }
diff --git a/boot/evaluator.cc b/boot/evaluator.cc
index 14ca889..d8d9ddc 100644
--- a/boot/evaluator.cc
+++ b/boot/evaluator.cc
@@ -73,31 +73,18 @@ namespace elna::boot
     {
         auto resolved = resolve_underlying_type(subject);
 
-        if (is_primitive_type(resolved, "Int")
-                || resolved.get<enumeration_type>() != nullptr)
+        if (resolved.get<enumeration_type>() != nullptr)
         {
-            return target.int_properties;
+            return target.word_properties.front();
         }
-        else if (is_primitive_type(resolved, "Word"))
-        {
-            return target.word_properties;
-        }
-        else if (is_primitive_type(resolved, "Char"))
+        else if (auto resolved_primitive = resolved.get<primitive_type>())
         {
-            return target.char_properties;
-        }
-        else if (is_primitive_type(resolved, "Float"))
-        {
-            return target.float_properties;
-        }
-        else if (is_primitive_type(resolved, "Bool"))
-        {
-            return target.bool_properties;
+            return resolved_primitive->properties;
         }
         else if (resolved.get<slice_type>() != nullptr)
         {
             return type_properties{
-                .size = target.pointer_properties.size + target.word_properties.size,
+                .size = target.pointer_properties.size + target.word_properties.front().size,
                 .alignment = target.pointer_properties.alignment
             };
         }
@@ -812,13 +799,23 @@ namespace elna::boot
         {
             type const resolved = resolve_underlying_type(subject.types.front());
 
-            if (is_primitive_type(resolved, "Int"))
-            {
-                return constant_value{ integer_literal::from(std::numeric_limits<std::ptrdiff_t>::min()) };
-            }
-            if (is_primitive_type(resolved, "Word"))
+            if (auto resolved_primitive = resolved.get<primitive_type>())
             {
-                return constant_value{ integer_literal::from<std::size_t>(0) };
+                if (resolved_primitive->identifier.starts_with("Int"))
+                {
+                    const std::size_t bits = resolved_primitive->properties.size * CHAR_BIT;
+                    const integer_literal one = integer_literal::from<std::ptrdiff_t>(
+                            resolved_primitive->properties.size, 1U).value();
+
+                    return constant_value{
+                        one.shl(integer_literal::from<std::size_t>(bits - 1U)).value()
+                    };
+                }
+                if (resolved_primitive->identifier.starts_with("Word"))
+                {
+                    return constant_value{ integer_literal::from<std::size_t>(
+                            resolved_primitive->properties.size, 0U).value() };
+                }
             }
             if (is_primitive_type(resolved, "Char"))
             {
@@ -841,13 +838,26 @@ namespace elna::boot
         {
             type const resolved = resolve_underlying_type(subject.types.front());
 
-            if (is_primitive_type(resolved, "Int"))
+            if (auto resolved_primitive = resolved.get<primitive_type>())
             {
-                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::size_t>::max()) };
+                if (resolved_primitive->identifier.starts_with("Int"))
+                {
+                    const std::size_t bits = resolved_primitive->properties.size * CHAR_BIT;
+                    const integer_literal one = integer_literal::from<std::ptrdiff_t>(
+                            resolved_primitive->properties.size, 1U).value();
+                    const std::optional<integer_literal> minimum = one.shl(
+                            integer_literal::from<std::size_t>(bits - 1U));
+
+                    return constant_value{ ~minimum.value() };
+                }
+                if (resolved_primitive->identifier.starts_with("Word"))
+                {
+                    // All bits set.
+                    std::optional<integer_literal> zero = integer_literal::from<std::size_t>(
+                            resolved_primitive->properties.size, 0U);
+
+                    return constant_value{ ~zero.value() };
+                }
             }
             if (is_primitive_type(resolved, "Char"))
             {
diff --git a/boot/lexer.ll b/boot/lexer.ll
index e944560..691034a 100644
--- a/boot/lexer.ll
+++ b/boot/lexer.ll
@@ -47,7 +47,9 @@ along with GCC; see the file COPYING3.  If not see
 ID1 [A-Za-z_]
 ID2 [A-Za-z0-9_]
 HIGIT [0-9a-fA-F]
+HEXADECIMAL 0[xX]{HIGIT}+
 BIGIT [01]
+NATURAL [1-9][[:digit:]]*
 
 %%
 %{
@@ -173,55 +175,158 @@ to {
 #{ID1}{ID2}* {
     return yy::parser::make_TRAIT(yytext + 1, this->location);
 }
-[[:digit:]]+u {
-    std::uint64_t result = strtoull(yytext, NULL, 10);
-
-    if (errno == ERANGE)
+(0|{NATURAL})u|{HEXADECIMAL} {
+    if (auto result = parse_integer<std::uint64_t>(yytext, 0))
+    {
+        return yy::parser::make_WORD(result.value(), this->location);
+    }
+    else
     {
         REJECT;
     }
+}
+(0|{NATURAL}|{HEXADECIMAL})u8 {
+    if (auto result = parse_integer<std::uint8_t>(yytext, 0))
+    {
+        return yy::parser::make_WORD8(result.value(), this->location);
+    }
     else
     {
-        return yy::parser::make_WORD(result, this->location);
+        REJECT;
     }
 }
-[[:digit:]]+ {
-    std::int64_t result = strtoll(yytext, NULL, 10);
-
-    if (errno == ERANGE)
+(0|{NATURAL}|{HEXADECIMAL})u16 {
+    if (auto result = parse_integer<std::uint16_t>(yytext, 0))
+    {
+        return yy::parser::make_WORD16(result.value(), this->location);
+    }
+    else
     {
         REJECT;
     }
+}
+(0|{NATURAL}|{HEXADECIMAL})u32 {
+    if (auto result = parse_integer<std::uint32_t>(yytext, 0))
+    {
+        return yy::parser::make_WORD32(result.value(), this->location);
+    }
     else
     {
-        return yy::parser::make_INTEGER(result, this->location);
+        REJECT;
     }
 }
-0[x|X]{HIGIT}+ {
-    std::uint64_t result = strtoull(yytext, NULL, 16);
-
-    if (errno == ERANGE)
+(0|{NATURAL}|{HEXADECIMAL})u64 {
+    if (auto result = parse_integer<std::uint64_t>(yytext, 0))
+    {
+        return yy::parser::make_WORD64(result.value(), this->location);
+    }
+    else
     {
         REJECT;
     }
+}
+0|{NATURAL} {
+    if (auto result = parse_integer<std::int64_t>(yytext, 10))
+    {
+        return yy::parser::make_INTEGER(result.value(), this->location);
+    }
     else
     {
-        return yy::parser::make_WORD(result, this->location);
+        REJECT;
     }
 }
-0[b|B]{BIGIT}+ {
-    std::uint64_t result = strtoull(yytext + 2, NULL, 2);
-
-    if (errno == ERANGE)
+(0|{NATURAL})i8 {
+    if (auto result = parse_integer<std::int8_t>(yytext, 10))
+    {
+        return yy::parser::make_INTEGER8(result.value(), this->location);
+    }
+    else
     {
         REJECT;
     }
+}
+(0|{NATURAL})i16 {
+    if (auto result = parse_integer<std::int16_t>(yytext, 10))
+    {
+        return yy::parser::make_INTEGER16(result.value(), this->location);
+    }
+    else
+    {
+        REJECT;
+    }
+}
+(0|{NATURAL})i32 {
+    if (auto result = parse_integer<std::int32_t>(yytext, 10))
+    {
+        return yy::parser::make_INTEGER32(result.value(), this->location);
+    }
     else
     {
-        return yy::parser::make_WORD(result, this->location);
+        REJECT;
+    }
+}
+(0|{NATURAL})i64 {
+    if (auto result = parse_integer<std::int64_t>(yytext, 10))
+    {
+        return yy::parser::make_INTEGER64(result.value(), this->location);
+    }
+    else
+    {
+        REJECT;
+    }
+}
+0[bB]{BIGIT}+ {
+    if (auto result = parse_integer<std::uint64_t>(yytext + 2, 2))
+    {
+        return yy::parser::make_WORD(result.value(), this->location);
+    }
+    else
+    {
+        REJECT;
+    }
+}
+0[bB]{BIGIT}+u8 {
+    if (auto result = parse_integer<std::uint8_t>(yytext + 2, 2))
+    {
+        return yy::parser::make_WORD8(result.value(), this->location);
+    }
+    else
+    {
+        REJECT;
+    }
+}
+0[bB]{BIGIT}+u16 {
+    if (auto result = parse_integer<std::uint16_t>(yytext + 2, 2))
+    {
+        return yy::parser::make_WORD16(result.value(), this->location);
+    }
+    else
+    {
+        REJECT;
+    }
+}
+0[bB]{BIGIT}+u32 {
+    if (auto result = parse_integer<std::uint32_t>(yytext + 2, 2))
+    {
+        return yy::parser::make_WORD32(result.value(), this->location);
+    }
+    else
+    {
+        REJECT;
+    }
+}
+0[bB]{BIGIT}+u64 {
+    if (auto result = parse_integer<std::uint64_t>(yytext + 2, 2))
+    {
+        return yy::parser::make_WORD64(result.value(), this->location);
+    }
+    else
+    {
+        REJECT;
     }
 }
 [[:digit:]]+\.[[:digit:]]+([eE][+-]?[[:digit:]]+)? {
+    errno = 0;
     double result = strtod(yytext, NULL);
 
     if (errno == ERANGE)
@@ -234,6 +339,7 @@ to {
     }
 }
 [[:digit:]]+[eE][+-]?[[:digit:]]+ {
+    errno = 0;
     double result = strtod(yytext, NULL);
 
     if (errno == ERANGE)
diff --git a/boot/materialization.cc b/boot/materialization.cc
new file mode 100644
index 0000000..e055dfd
--- /dev/null
+++ b/boot/materialization.cc
@@ -0,0 +1,62 @@
+/* Literal sign folding.
+   Copyright (C) 2025 Free Software Foundation, Inc.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#include "elna/boot/materialization.h"
+
+namespace elna::boot
+{
+    materialization_error::materialization_error(const source_position position)
+        : error(position)
+    {
+    }
+
+    std::string materialization_error::what() const
+    {
+        return "Integer literal overflows";
+    }
+
+    materialization_visitor::materialization_visitor(const target_info& target)
+        : target(target)
+    {
+    }
+
+    void materialization_visitor::visit(literal<integer_literal> *literal)
+    {
+        switch (literal->wants_signed)
+        {
+            using enum integer_sign;
+            case negative:
+                if (auto negated_literal = literal->value.negate())
+                {
+                    literal->value = negated_literal.value();
+                }
+                else
+                {
+                    add_error<materialization_error>(literal->position());
+                }
+                break;
+            case unmarked:
+                if (!literal->value.fit_into(true, literal->value.size()))
+                {
+                    add_error<materialization_error>(literal->position());
+                }
+                break;
+            case _unsigned:
+                break;
+        }
+    }
+}
diff --git a/boot/name_analysis.cc b/boot/name_analysis.cc
index 56ea399..ae6810d 100644
--- a/boot/name_analysis.cc
+++ b/boot/name_analysis.cc
@@ -69,23 +69,53 @@ namespace elna::boot
         return std::nullopt;
     }
 
-    const_qualifier_error::const_qualifier_error(const source_position position, kind error_kind)
-        : error(position), error_kind(error_kind)
+    name_analysis_error::name_analysis_error(const source_position position, payload_type payload)
+        : error(position), payload(std::move(payload))
     {
     }
 
-    std::string const_qualifier_error::what() const
+    std::string name_analysis_error::what() const
     {
-        switch (error_kind)
-        {
-            using enum kind;
-            case array_position:
-                return "const must be written before the array size, not after";
-            case duplicate:
-                return "Duplicate 'const' qualifier is not allowed";
-            default:
-                __builtin_unreachable();
-        }
+        return std::visit([](const auto& payload) -> std::string {
+            using T = std::decay_t<decltype(payload)>;
+
+            if constexpr (std::is_same_v<T, not_initialized>)
+            {
+                return "All constants should be initialized";
+            }
+            else if constexpr (std::is_same_v<T, kind>)
+            {
+                switch (payload)
+                {
+                    using enum kind;
+                    case array_position:
+                        return "const must be written before the array size, not after";
+                    case duplicate:
+                        return "Duplicate 'const' qualifier is not allowed";
+                    default:
+                        __builtin_unreachable();
+                }
+            }
+        }, this->payload);
+    }
+
+    std::optional<std::pair<std::string, source_position>> name_analysis_error::note() const
+    {
+        return std::visit([](const auto& payload) -> std::optional<std::pair<std::string, source_position>> {
+            using T = std::decay_t<decltype(payload)>;
+
+            if constexpr (std::is_same_v<T, not_initialized>)
+            {
+                auto position_span = source_position(payload.identifiers.front().position().start(),
+                        payload.identifiers.back().position().end());
+
+                return std::make_optional(std::make_pair(join(payload.identifiers), position_span));
+            }
+            else
+            {
+                return std::nullopt;
+            }
+        }, this->payload);
     }
 
     member_error::member_error(const source_position position, const std::string& name,
@@ -164,23 +194,6 @@ namespace elna::boot
         return std::nullopt;
     }
 
-    not_initialized_error::not_initialized_error(const source_position position, std::vector<identifier> identifiers)
-        : error(position), identifiers(std::move(identifiers))
-    {
-    }
-
-    std::string not_initialized_error::what() const
-    {
-        return "All constants should be initialized";
-    }
-
-    std::optional<std::pair<std::string, source_position>> not_initialized_error::note() const
-    {
-        auto position_span = source_position(this->identifiers.front().position().start(),
-                this->identifiers.back().position().end());
-        return std::make_pair(join(this->identifiers), position_span);
-    }
-
     // Members of a constant aggregate are constant themselves.
     static type qualify_member_type(const type& element, const type& aggregate)
     {
@@ -304,8 +317,8 @@ namespace elna::boot
 
         if (this->current_type.get<constant_type>() != nullptr)
         {
-            add_error<const_qualifier_error>(expression->position(),
-                    const_qualifier_error::kind::duplicate);
+            add_error<name_analysis_error>(expression->position(),
+                    name_analysis_error::kind::duplicate);
         }
         this->current_type = type(std::make_shared<constant_type>(this->current_type));
     }
@@ -317,8 +330,8 @@ namespace elna::boot
 
         if (array_base.get<constant_type>() != nullptr)
         {
-            add_error<const_qualifier_error>(expression->position(),
-                    const_qualifier_error::kind::array_position);
+            add_error<name_analysis_error>(expression->position(),
+                    name_analysis_error::kind::array_position);
         }
         expression->dimensions().accept(this);
         const auto size_constant = this->constant_evaluator.evaluate_index(expression->dimensions());
@@ -567,8 +580,8 @@ namespace elna::boot
         {
                 auto position_span = source_position(declaration->identifiers.front().id().position().start(),
                         declaration->identifiers.back().id().position().end());
-                add_error<not_initialized_error>(position_span,
-                        extract_identifiers(declaration->identifiers));
+                add_error<name_analysis_error>(position_span,
+                        name_analysis_error::not_initialized{ extract_identifiers(declaration->identifiers) });
         }
         for (const identifier_definition& variable_identifier : declaration->identifiers)
         {
@@ -881,11 +894,27 @@ namespace elna::boot
     {
         if (literal->value.is_signed())
         {
-            literal->type_decoration = lookup_primitive_type("Int");
+            if (literal->has_explicit_size)
+            {
+                literal->type_decoration = lookup_primitive_type(
+                        "Int" + std::to_string(literal->value.size() * CHAR_BIT));
+            }
+            else
+            {
+                literal->type_decoration = lookup_primitive_type("Int");
+            }
         }
         else
         {
-            literal->type_decoration = lookup_primitive_type("Word");
+            if (literal->has_explicit_size)
+            {
+                literal->type_decoration = lookup_primitive_type(
+                        "Word" + std::to_string(literal->value.size() * CHAR_BIT));
+            }
+            else
+            {
+                literal->type_decoration = lookup_primitive_type("Word");
+            }
         }
         this->current_type = type();
     }
@@ -921,20 +950,8 @@ namespace elna::boot
         this->current_type = type();
     }
 
-    declaration_visitor::declaration_visitor()
-    {
-    }
-
-    void declaration_visitor::visit(import_declaration *)
-    {
-    }
-
     void declaration_visitor::visit(unit *unit)
     {
-        for (import_declaration *const _import : unit->imports)
-        {
-            _import->accept(this);
-        }
         for (type_declaration *const type : unit->types)
         {
             type->accept(this);
diff --git a/boot/parser.yy b/boot/parser.yy
index a28b6cb..b48510b 100644
--- a/boot/parser.yy
+++ b/boot/parser.yy
@@ -78,8 +78,10 @@ along with GCC; see the file COPYING3.  If not see
 
 %token <std::string> IDENTIFIER
 %token <std::string> TRAIT
-%token <std::int64_t> INTEGER
-%token <std::uint64_t> WORD
+%token <std::pair<std::uint64_t, elna::boot::integer_sign>> INTEGER INTEGER64 WORD WORD64
+%token <std::pair<std::uint8_t, elna::boot::integer_sign>> INTEGER8 WORD8
+%token <std::pair<std::uint16_t, elna::boot::integer_sign>> INTEGER16 WORD16
+%token <std::pair<std::uint32_t, elna::boot::integer_sign>> INTEGER32 WORD32
 %token <double> FLOAT
 %token <std::string> CHARACTER
 %token <std::string> STRING
@@ -130,8 +132,7 @@ along with GCC; see the file COPYING3.  If not see
 %type <std::vector<elna::boot::variable_declaration *>> variable_declarations variable_part;
 %type <elna::boot::type_expression *> type_expression;
 %type <std::vector<elna::boot::type_expression *>> type_expressions;
-%type <elna::boot::expression *> expression operand simple_expression procedure_return;
-%type <elna::boot::unary_expression *> unary_expression;
+%type <elna::boot::expression *> expression operand simple_expression procedure_return unary_expression;
 %type <elna::boot::binary_expression *> binary_expression;
 %type <std::vector<elna::boot::expression *>> expressions actual_parameter_list;
 %type <elna::boot::designator_expression *> designator_expression;
@@ -237,13 +238,86 @@ procedure_return:
     "return" expression { $$ = $2; }
     | "return" { $$ = nullptr; }
 literal:
-    INTEGER { $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$), boot::integer_literal::from($1)); }
-    | WORD { $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$), boot::integer_literal::from($1)); }
-    | FLOAT { $$ = new boot::literal<double>(boot::make_position(@$), $1); }
-    | BOOLEAN { $$ = new boot::literal<bool>(boot::make_position(@$), $1); }
-    | CHARACTER { $$ = new boot::literal<unsigned char>(boot::make_position(@$), $1.at(0)); }
-    | "nil" { $$ = new boot::literal<std::nullptr_t>(boot::make_position(@$), nullptr); }
-    | STRING { $$ = new boot::literal<std::string>(boot::make_position(@$), $1); }
+    INTEGER
+        {
+            auto [magnitude, wants_signed] = $1;
+            $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                    boot::integer_literal::from(magnitude), wants_signed, false);
+        }
+    | INTEGER8
+        {
+            auto [magnitude, wants_signed] = $1;
+            $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                    boot::integer_literal::from(magnitude), wants_signed);
+        }
+    | INTEGER16
+        {
+            auto [magnitude, wants_signed] = $1;
+            $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                    boot::integer_literal::from(magnitude), wants_signed);
+        }
+    | INTEGER32
+        {
+            auto [magnitude, wants_signed] = $1;
+            $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                    boot::integer_literal::from(magnitude), wants_signed);
+        }
+    | INTEGER64
+        {
+            auto [magnitude, wants_signed] = $1;
+            $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                    boot::integer_literal::from(magnitude), wants_signed);
+        }
+    | WORD
+        {
+            auto [magnitude, wants_signed] = $1;
+            $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                    boot::integer_literal::from(magnitude), wants_signed, false);
+        }
+    | WORD8
+        {
+            auto [magnitude, wants_signed] = $1;
+            $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                    boot::integer_literal::from(magnitude), wants_signed);
+        }
+    | WORD16
+        {
+            auto [magnitude, wants_signed] = $1;
+            $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                    boot::integer_literal::from(magnitude), wants_signed);
+        }
+    | WORD32
+        {
+            auto [magnitude, wants_signed] = $1;
+            $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                    boot::integer_literal::from(magnitude), wants_signed);
+        }
+    | WORD64
+        {
+            auto [magnitude, wants_signed] = $1;
+            $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                    boot::integer_literal::from(magnitude), wants_signed);
+        }
+    | FLOAT
+        {
+            $$ = new boot::literal<double>(boot::make_position(@$), $1, boot::integer_sign::unmarked);
+        }
+    | BOOLEAN
+        {
+            $$ = new boot::literal<bool>(boot::make_position(@$), $1, boot::integer_sign::_unsigned);
+        }
+    | CHARACTER
+        {
+            $$ = new boot::literal<unsigned char>(boot::make_position(@$), $1.at(0), boot::integer_sign::_unsigned);
+        }
+    | "nil"
+        {
+            $$ = new boot::literal<std::nullptr_t>(boot::make_position(@$), nullptr, boot::integer_sign::_unsigned);
+        }
+    | STRING
+        {
+            $$ = new boot::literal<std::string>(boot::make_position(@$), $1, boot::integer_sign::_unsigned);
+        }
 simple_expression:
     literal { $$ = $1; }
     | designator_expression { $$ = $1; }
@@ -348,7 +422,25 @@ unary_expression:
         }
     | "-" operand
         {
-            $$ = new boot::unary_expression(boot::make_position(@$), $2, boot::unary_operator::minus);
+            auto operand = $2;
+            auto integer_operand = operand->is_literal() == nullptr
+                ? nullptr
+                : operand->is_literal()->is_a<boot::integer_literal>();
+
+            if (integer_operand != nullptr
+                    && integer_operand->wants_signed == boot::integer_sign::unmarked)
+            {
+                // Rebuild the literal with a position spanning the minus and the
+                // integer token.
+                $$ = new boot::literal<boot::integer_literal>(boot::make_position(@$),
+                        integer_operand->value, boot::integer_sign::negative,
+                        integer_operand->has_explicit_size);
+                delete integer_operand;
+            }
+            else
+            {
+                $$ = new boot::unary_expression(boot::make_position(@$), operand, boot::unary_operator::minus);
+            }
         }
     | "+" operand
         {
diff --git a/boot/result.cc b/boot/result.cc
index 30b4576..15fe8b4 100644
--- a/boot/result.cc
+++ b/boot/result.cc
@@ -226,7 +226,7 @@ namespace elna::boot
 
     std::optional<integer_literal> integer_literal::neg() const
     {
-        if (!is_signed() || is_negative_minimum())
+        if (!is_signed() || is_negative_minimum(bits()))
         {
             return std::nullopt;
         }
@@ -237,32 +237,44 @@ namespace elna::boot
         return result;
     }
 
+    std::optional<integer_literal> integer_literal::negate() const
+    {
+        integer_literal result{ true, this->m_size };
+
+        mpz_set(result.raw, this->raw);
+        mpz_neg(result.raw, result.raw);
+
+        return std::move(result).check();
+    }
+
     std::optional<integer_literal> integer_literal::shl(const integer_literal& that) const
     {
         if (that >= bits())
         {
             return std::nullopt;
         }
-        integer_literal result = *this;
-
-        mpz_mul_2exp(result.raw, this->raw, static_cast<mp_bitcnt_t>(mpz_get_ui(that.raw)));
+        else
+        {
+            integer_literal result = *this;
 
-        return std::move(result).check();
+            mpz_mul_2exp(result.raw, this->raw, static_cast<mp_bitcnt_t>(mpz_get_ui(that.raw)));
+            return std::make_optional(std::move(result).cast_to(is_signed(), size()));
+        }
     }
 
     std::optional<integer_literal> integer_literal::shr(const integer_literal& that) const
     {
-        integer_literal result = *this;
-
         if (that >= bits())
         {
-            mpz_set_si(result.raw, *this > 0 ? 0 : -1);
+            return std::nullopt;
         }
         else
         {
+            integer_literal result = *this;
+
             mpz_fdiv_q_2exp(result.raw, this->raw, static_cast<mp_bitcnt_t>(mpz_get_ui(that.raw)));
+            return std::make_optional(std::move(result));
         }
-        return std::make_optional(std::move(result));
     }
 
     integer_literal integer_literal::operator|(const integer_literal& that) const
@@ -298,7 +310,7 @@ namespace elna::boot
 
         mpz_com(result.raw, this->raw);
 
-        return result;
+        return std::move(result).cast_to(is_signed(), size());
     }
 
     bool integer_literal::operator==(const integer_literal& that) const
@@ -328,16 +340,49 @@ namespace elna::boot
         return *this;
     }
 
-    bool integer_literal::fit_into(const std::size_t target_size)
+    bool integer_literal::fit_into(bool target_signed, const std::size_t target_size)
     {
-        if (fits_in(target_size * CHAR_BIT))
+        if (fits_in(target_signed, target_size * CHAR_BIT))
         {
+            this->m_signed = target_signed;
             this->m_size = target_size;
             return true;
         }
         return false;
     }
 
+    bool integer_literal::fit_into(const std::size_t target_size)
+    {
+        return fit_into(is_signed(), target_size);
+    }
+
+    integer_literal integer_literal::cast_to(bool target_signed, std::size_t target_size) const
+    {
+        integer_literal result{ target_signed, target_size };
+        const std::size_t bits = target_size * CHAR_BIT;
+
+        // Reduce to the unsigned residue in [0, 2^bits). This is the bit pattern
+        // resulting from truncating or zero-extending in two's complement,
+        // regardless of the source's sign.
+        mpz_fdiv_r_2exp(result.raw, this->raw, bits);
+
+        // Since GMP doesn't store the value as 2's complement, if the value is
+        // signed it should be converted manually.
+        if (target_signed && mpz_tstbit(result.raw, bits - 1))
+        {
+            mpz_t modulus;
+
+            mpz_init(modulus);
+            mpz_set_ui(modulus, 1);
+            mpz_mul_2exp(modulus, modulus, bits);
+
+            mpz_sub(result.raw, result.raw, modulus);
+
+            mpz_clear(modulus);
+        }
+        return result;
+    }
+
     bool integer_literal::is_signed() const
     {
         return this->m_signed;
@@ -367,30 +412,27 @@ namespace elna::boot
         std::swap(lhs.m_size, rhs.m_size);
     }
 
-    bool integer_literal::fits_in(const std::size_t bits) const
+    bool integer_literal::fits_in(bool target_signed, const std::size_t bits) const
     {
         std::size_t required_bits = mpz_sizeinbase(this->raw, 2);
 
-        if (!is_negative() || !is_negative_minimum(bits))
+        if (target_signed && !is_negative_minimum(bits))
         {
             ++required_bits; // Add one bit for the sign.
         }
-        return required_bits <= bits && (!is_negative() || is_signed());
+        return required_bits <= bits && (!is_negative() || target_signed);
     }
 
     std::optional<integer_literal> integer_literal::check() &&
     {
-        return fits_in(bits()) ? std::make_optional(std::move(*this)) : std::nullopt;
+        return fits_in(is_signed(), bits())
+            ? std::make_optional(std::move(*this))
+            : std::nullopt;
     }
 
     bool integer_literal::is_negative_minimum(const std::size_t bits) const
     {
-        return mpz_scan1(this->raw, 0) == bits - 1;
-    }
-
-    bool integer_literal::is_negative_minimum() const
-    {
-        return is_negative() && is_negative_minimum(bits());
+        return is_negative() && mpz_scan1(this->raw, 0) == bits - 1;
     }
 
     std::size_t integer_literal::bits() const
diff --git a/boot/symbol.cc b/boot/symbol.cc
index 1cc652c..9854acc 100644
--- a/boot/symbol.cc
+++ b/boot/symbol.cc
@@ -184,8 +184,8 @@ namespace elna::boot
         }, payload);
     }
 
-    alias_type::alias_type(const std::string& name)
-        : name(name) 
+    alias_type::alias_type(const std::string& name, type referent)
+        : name(name), referent(std::move(referent))
     {
     }
 
@@ -209,8 +209,8 @@ namespace elna::boot
     {
     }
 
-    primitive_type::primitive_type(const std::string& identifier)
-        : identifier(identifier)
+    primitive_type::primitive_type(const std::string& identifier, const type_properties& properties)
+        : identifier(identifier), properties(properties)
     {
     }
 
@@ -282,16 +282,42 @@ namespace elna::boot
         return std::static_pointer_cast<variable_info>(shared_from_this());
     }
 
-    std::shared_ptr<symbol_table> builtin_symbol_table()
+    static void builtin_integers(const std::shared_ptr<symbol_table>& symbols,
+            const std::array<type_properties, target_integer_count>& properties,
+            const std::string& integer_name)
+    {
+        for (std::size_t i = 1; i < properties.size(); ++i)
+        {
+            const std::size_t bit_size = properties[i].size * CHAR_BIT;
+            const std::string type_name = integer_name + std::to_string(bit_size);
+            const type variant_type = type(std::make_shared<primitive_type>(type_name, properties[i]));
+
+            symbols->enter(type_name, std::make_shared<type_info>(variant_type));
+        }
+        if (!symbols->contains(integer_name))
+        {
+            auto variant_type = type(std::make_shared<primitive_type>(integer_name, properties.front()));
+
+            symbols->enter(integer_name, std::make_shared<type_info>(variant_type));
+        }
+    }
+
+    std::shared_ptr<symbol_table> builtin_symbol_table(const target_info& target)
     {
         auto result = std::make_shared<symbol_table>();
 
-        result->enter("Int", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Int"))));
-        result->enter("Word", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Word"))));
-        result->enter("Char", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Char"))));
-        result->enter("Pointer", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Pointer"))));
-        result->enter("Float", std::make_shared<type_info>(type(std::make_shared<primitive_type>("Float"))));
-        type const boolean = type(std::make_shared<primitive_type>("Bool"));
+        builtin_integers(result, target.int_properties, "Int");
+        builtin_integers(result, target.word_properties, "Word");
+
+        result->enter("Char",
+                std::make_shared<type_info>(type(std::make_shared<primitive_type>("Char", target.char_properties))));
+
+        const type pointer = type(std::make_shared<primitive_type>("Pointer", target.pointer_properties));
+        result->enter("Pointer", std::make_shared<type_info>(pointer));
+        result->enter("Float",
+                std::make_shared<type_info>(type(std::make_shared<primitive_type>("Float", target.float_properties))));
+
+        const type boolean = type(std::make_shared<primitive_type>("Bool", target.bool_properties));
         result->enter("Bool", std::make_shared<type_info>(boolean));
 
         procedure_type assert_symbol{ procedure_type::return_t() };
@@ -426,15 +452,18 @@ namespace elna::boot
 
     bool is_numeric_type(const type& checked)
     {
-        return is_primitive_type(checked, "Int")
-            || is_primitive_type(checked, "Word")
+        return is_integral_type(checked)
             || is_primitive_type(checked, "Float");
     }
 
     bool is_integral_type(const type& checked)
     {
-        return is_primitive_type(checked, "Int")
-            || is_primitive_type(checked, "Word");
+        if (auto primitive_checked = checked.get<primitive_type>())
+        {
+            return primitive_checked->identifier.starts_with("Int")
+                || primitive_checked->identifier.starts_with("Word");
+        }
+        return false;
     }
 
     bool is_discrete_type(const type& checked)
diff --git a/boot/type_check.cc b/boot/type_check.cc
index 78e975a..b1739d9 100644
--- a/boot/type_check.cc
+++ b/boot/type_check.cc
@@ -1038,11 +1038,11 @@ namespace elna::boot
         bool narrowed{ false };
         if (expression->value.is_signed())
         {
-            narrowed = expression->value.fit_into(target.int_properties.size);
+            narrowed = expression->value.fit_into(target.int_properties.front().size);
         }
         else
         {
-            narrowed = expression->value.fit_into(target.word_properties.size);
+            narrowed = expression->value.fit_into(target.word_properties.front().size);
         }
         if (!narrowed)
         {
diff --git a/boot/validation.cc b/boot/validation.cc
index b29381a..0c03fd0 100644
--- a/boot/validation.cc
+++ b/boot/validation.cc
@@ -55,6 +55,38 @@ namespace elna::boot
     {
     }
 
+    void validation_visitor::visit(assign_statement *)
+    {
+    }
+
+    void validation_visitor::visit(if_statement *)
+    {
+    }
+
+    void validation_visitor::visit(while_statement *)
+    {
+    }
+
+    void validation_visitor::visit(repeat_statement *)
+    {
+    }
+
+    void validation_visitor::visit(for_statement *)
+    {
+    }
+
+    void validation_visitor::visit(defer_statement *)
+    {
+    }
+
+    void validation_visitor::visit(empty_statement *)
+    {
+    }
+
+    void validation_visitor::visit(procedure_call *)
+    {
+    }
+
     void validation_visitor::visit(unit *unit)
     {
         for (procedure_declaration *procedure : unit->procedures)
@@ -73,17 +105,31 @@ namespace elna::boot
         {
             auto procedure = this->bag.lookup(declaration->identifier.name())->is_procedure();
             this->bag.enter(procedure->scope);
-        }
-        walking_visitor::visit(declaration);
-        if (declaration->body.has_value())
-        {
+            for (auto *statement : declaration->body.value().entry_point)
+            {
+                statement->accept(this);
+            }
             this->bag.leave();
         }
     }
 
     void validation_visitor::visit(case_statement *statement)
     {
-        walking_visitor::visit(statement);
+        for (const switch_case& case_block : statement->cases)
+        {
+            for (auto *block_statement : case_block.statements)
+            {
+                block_statement->accept(this);
+            }
+        }
+        if (statement->alternative != nullptr)
+        {
+            for (auto *block_statement : *statement->alternative)
+            {
+                block_statement->accept(this);
+            }
+        }
+
         std::unordered_map<constant_value, source_position, constant_value_hash> seen;
         for (const auto& case_block : statement->cases)
         {
diff --git a/gcc/Make-lang.in b/gcc/Make-lang.in
index 690d047..bf1893d 100644
--- a/gcc/Make-lang.in
+++ b/gcc/Make-lang.in
@@ -58,6 +58,7 @@ elna_OBJS = \
 	elna/symbol.o \
 	elna/result.o \
 	elna/validation.o \
+	elna/materialization.o \
 	$(END)
 
 elna1$(exeext): attribs.o $(elna_OBJS) $(BACKEND) $(LIBDEPS)
diff --git a/gcc/gcc/elna-builtins.cc b/gcc/gcc/elna-builtins.cc
index 7c4545e..4f3db65 100644
--- a/gcc/gcc/elna-builtins.cc
+++ b/gcc/gcc/elna-builtins.cc
@@ -25,6 +25,43 @@ along with GCC; see the file COPYING3.  If not see
 
 namespace elna::gcc
 {
+    static constexpr boot::type_properties get_host_numeric_properties(tree node)
+    {
+        return boot::type_properties{
+            .size = static_cast<std::size_t>(TYPE_PRECISION(node) / BITS_PER_UNIT),
+            .alignment = TYPE_ALIGN_UNIT(node)
+        };
+    }
+
+    const boot::target_info& get_host_target()
+    {
+        static const boot::target_info info = boot::target_info{
+            .int_properties = {
+                get_host_numeric_properties(elna_int_type_node),
+                get_host_numeric_properties(intQI_type_node),
+                get_host_numeric_properties(intHI_type_node),
+                get_host_numeric_properties(intSI_type_node),
+                get_host_numeric_properties(intDI_type_node)
+            },
+            .word_properties = {
+                get_host_numeric_properties(elna_word_type_node),
+                get_host_numeric_properties(unsigned_intQI_type_node),
+                get_host_numeric_properties(unsigned_intHI_type_node),
+                get_host_numeric_properties(unsigned_intSI_type_node),
+                get_host_numeric_properties(unsigned_intDI_type_node)
+            },
+            .pointer_properties = get_host_numeric_properties(ptr_type_node),
+            .char_properties = get_host_numeric_properties(elna_char_type_node),
+            .float_properties = get_host_numeric_properties(elna_float_type_node),
+            .bool_properties = {
+                .size = static_cast<std::size_t>(
+                        (TYPE_PRECISION(elna_bool_type_node) + BITS_PER_UNIT - 1) / BITS_PER_UNIT),
+                .alignment = TYPE_ALIGN_UNIT(elna_bool_type_node)
+            }
+        };
+        return info;
+    }
+
     void init_ttree()
     {
         elna_int_type_node = ptrdiff_type_node;
@@ -56,7 +93,15 @@ namespace elna::gcc
         auto builtin_table = std::make_shared<symbol_table>();
 
         declare_builtin_type(builtin_table, "Int", elna_int_type_node);
+        declare_builtin_type(builtin_table, "Int8", intQI_type_node);
+        declare_builtin_type(builtin_table, "Int16", intHI_type_node);
+        declare_builtin_type(builtin_table, "Int32", intSI_type_node);
+        declare_builtin_type(builtin_table, "Int64", intDI_type_node);
         declare_builtin_type(builtin_table, "Word", elna_word_type_node);
+        declare_builtin_type(builtin_table, "Word8", unsigned_intQI_type_node);
+        declare_builtin_type(builtin_table, "Word16", unsigned_intHI_type_node);
+        declare_builtin_type(builtin_table, "Word32", unsigned_intSI_type_node);
+        declare_builtin_type(builtin_table, "Word64", unsigned_intDI_type_node);
         declare_builtin_type(builtin_table, "Char", elna_char_type_node);
         declare_builtin_type(builtin_table, "Bool", elna_bool_type_node);
         declare_builtin_type(builtin_table, "Pointer", elna_pointer_type_node);
diff --git a/gcc/gcc/elna-tree.cc b/gcc/gcc/elna-tree.cc
index 05690d6..688fc4a 100644
--- a/gcc/gcc/elna-tree.cc
+++ b/gcc/gcc/elna-tree.cc
@@ -28,29 +28,6 @@ along with GCC; see the file COPYING3.  If not see
 
 namespace elna::gcc
 {
-    const elna::boot::target_info& get_host_target()
-    {
-        static const elna::boot::target_info info = []{
-            elna::boot::target_info target_info;
-
-            target_info.int_properties.size = TYPE_PRECISION(elna_int_type_node) / BITS_PER_UNIT;
-            target_info.int_properties.alignment = TYPE_ALIGN_UNIT(elna_int_type_node);
-            target_info.word_properties.size = TYPE_PRECISION(elna_word_type_node) / BITS_PER_UNIT;
-            target_info.word_properties.alignment = TYPE_ALIGN_UNIT(elna_word_type_node);
-            target_info.pointer_properties.size = TYPE_PRECISION(ptr_type_node) / BITS_PER_UNIT;
-            target_info.pointer_properties.alignment = TYPE_ALIGN_UNIT(ptr_type_node);
-            target_info.char_properties.size = TYPE_PRECISION(elna_char_type_node) / BITS_PER_UNIT;
-            target_info.char_properties.alignment = TYPE_ALIGN_UNIT(elna_char_type_node);
-            target_info.float_properties.size = TYPE_PRECISION(elna_float_type_node) / BITS_PER_UNIT;
-            target_info.float_properties.alignment = TYPE_ALIGN_UNIT(elna_float_type_node);
-            target_info.bool_properties.size = (TYPE_PRECISION(elna_bool_type_node) + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
-            target_info.bool_properties.alignment = TYPE_ALIGN_UNIT(elna_bool_type_node);
-
-            return target_info;
-        }();
-        return info;
-    }
-
     bool is_integral_type(tree type)
     {
         gcc_assert(TYPE_P(type));
diff --git a/gcc/gcc/elna1.cc b/gcc/gcc/elna1.cc
index 4eb01cc..180c839 100644
--- a/gcc/gcc/elna1.cc
+++ b/gcc/gcc/elna1.cc
@@ -102,7 +102,8 @@ static elna::boot::dependency elna_parse_file(dependency_state& state, const cha
         fatal_error(UNKNOWN_LOCATION, "Cannot open filename %s: %m", filename);
     }
     const elna::gcc::linemap_guard guard(filename);
-    elna::boot::dependency outcome = elna::boot::read_source(entry_point);
+    elna::boot::dependency outcome = elna::boot::read_source(entry_point,
+            elna::gcc::get_host_target());
 
     elna::boot::symbol_bag outcome_bag{ std::move(outcome.unresolved), state.globals };
 
@@ -139,7 +140,8 @@ static elna::boot::dependency elna_parse_file(dependency_state& state, const cha
 
 static void elna_langhook_parse_file()
 {
-    dependency_state state{ elna::gcc::builtin_symbol_table() };
+    elna::boot::target_info target = elna::gcc::get_host_target();
+    dependency_state state{ elna::gcc::builtin_symbol_table(), target };
 
     for (unsigned int i = 0; i < num_in_fnames; i++)
     {
@@ -149,7 +151,7 @@ static void elna_langhook_parse_file()
         {
             linemap_add(line_table, LC_ENTER, 0, in_fnames[i], 1);
             elna::gcc::generic_visitor generic_visitor{ state.custom,
-                state.find(in_fnames[i])->second, elna::gcc::get_host_target() };
+                state.find(in_fnames[i])->second, target };
             outcome.tree->accept(&generic_visitor);
             linemap_add(line_table, LC_LEAVE, 0, nullptr, 0);
         }
diff --git a/include/elna/boot/ast.h b/include/elna/boot/ast.h
index 1ea17fb..2645026 100644
--- a/include/elna/boot/ast.h
+++ b/include/elna/boot/ast.h
@@ -62,6 +62,55 @@ namespace elna::boot
         plus
     };
 
+    enum class integer_sign
+    {
+        _unsigned,
+        unmarked,
+        negative
+    };
+
+    template<typename T>
+    struct literal_type_id;
+
+    template<>
+    struct literal_type_id<integer_literal>
+    {
+        static constexpr int value = 1;
+    };
+
+    template<>
+    struct literal_type_id<double>
+    {
+        static constexpr int value = 2;
+    };
+
+    template<>
+    struct literal_type_id<bool>
+    {
+        static constexpr int value = 3;
+    };
+
+    template<>
+    struct literal_type_id<unsigned char>
+    {
+        static constexpr int value = 4;
+    };
+
+    template<>
+    struct literal_type_id<std::nullptr_t>
+    {
+        static constexpr int value = 5;
+    };
+
+    template<>
+    struct literal_type_id<std::string>
+    {
+        static constexpr int value = 6;
+    };
+
+    template<typename T>
+    concept literal_type = requires { literal_type_id<T>::value; };
+
     class variable_declaration;
     class procedure_declaration;
     class type_declaration;
@@ -95,7 +144,7 @@ namespace elna::boot
     class dereference_expression;
     class designator_expression;
     class literal_expression;
-    template<typename T>
+    template<literal_type T>
     class literal;
     class defer_statement;
     class empty_statement;
@@ -488,6 +537,16 @@ namespace elna::boot
     {
     public:
         literal_expression *is_literal() override;
+
+        virtual int tag() const = 0;
+
+        template<literal_type T>
+        literal<T> *is_a()
+        {
+            return tag() == literal_type_id<T>::value
+                ? static_cast<literal<T > *>(this)
+                : nullptr;
+        }
     };
 
     /**
@@ -893,14 +952,17 @@ namespace elna::boot
         ~unit() override;
     };
 
-    template<typename T>
+    template<literal_type T>
     class literal : public literal_expression
     {
     public:
         T value;
+        const integer_sign wants_signed;
+        const bool has_explicit_size;
 
-        literal(const source_position position, const T& value)
-            : node(position), value(value)
+        literal(const source_position position, const T& value, const integer_sign wants_signed,
+                const bool has_explicit_size = true)
+            : node(position), value(value), wants_signed(wants_signed), has_explicit_size(has_explicit_size)
         {
         }
 
@@ -908,6 +970,11 @@ namespace elna::boot
         {
             visitor->visit(this);
         }
+
+        int tag() const override
+        {
+            return literal_type_id<T>::value;
+        }
     };
 
     class defer_statement : public statement
diff --git a/include/elna/boot/dependency.h b/include/elna/boot/dependency.h
index b3c1155..854c661 100644
--- a/include/elna/boot/dependency.h
+++ b/include/elna/boot/dependency.h
@@ -37,7 +37,7 @@ namespace elna::boot
         dependency() = default;
     };
 
-    dependency read_source(std::istream& entry_point);
+    dependency read_source(std::istream& entry_point, const target_info& target);
     std::filesystem::path build_path(const std::vector<std::string>& segments);
     error_list analyze_semantics(std::unique_ptr<unit>& tree, symbol_bag& bag,
             const target_info& target);
@@ -54,8 +54,8 @@ namespace elna::boot
         using iterator = std::unordered_map<std::filesystem::path, symbol_bag>::iterator;
         using const_iterator = std::unordered_map<std::filesystem::path, symbol_bag>::const_iterator;
 
-        explicit dependency_state(T custom)
-            : globals(builtin_symbol_table()), custom(custom)
+        explicit dependency_state(T custom, const target_info& target)
+            : globals(builtin_symbol_table(target)), custom(custom)
         {
         }
 
diff --git a/include/elna/boot/driver.h b/include/elna/boot/driver.h
index 60d40fb..2503e39 100644
--- a/include/elna/boot/driver.h
+++ b/include/elna/boot/driver.h
@@ -54,4 +54,20 @@ namespace elna::boot
      */
     void normalize_newlines(std::string& string);
     std::optional<std::string> escape_string(const char *escape);
+
+    template<typename T>
+    std::optional<std::pair<std::make_unsigned_t<T>, integer_sign>>
+    parse_integer(const char *text, const int base = 10)
+    {
+        using unsigned_t = std::make_unsigned_t<T>;
+        errno = 0;
+        std::uint64_t result = strtoull(text, nullptr, base);
+
+        if (errno == ERANGE || result > std::numeric_limits<unsigned_t>::max())
+        {
+            return std::nullopt;
+        }
+        return std::make_pair(static_cast<unsigned_t>(result),
+                std::is_signed_v<T> ? integer_sign::unmarked : integer_sign::_unsigned);
+    }
 }
diff --git a/include/elna/boot/materialization.h b/include/elna/boot/materialization.h
new file mode 100644
index 0000000..21a217d
--- /dev/null
+++ b/include/elna/boot/materialization.h
@@ -0,0 +1,41 @@
+/* Literal sign folding.
+   Copyright (C) 2025 Free Software Foundation, Inc.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+
+#pragma once
+
+#include "elna/boot/ast.h"
+
+namespace elna::boot
+{
+    class materialization_error final : public error
+    {
+    public:
+        materialization_error(const source_position position);
+
+        std::string what() const override;
+    };
+
+    class materialization_visitor final : public walking_visitor, public error_container
+    {
+        const target_info& target;
+
+    public:
+        explicit materialization_visitor(const target_info& target);
+
+        void visit(literal<integer_literal> *literal) override;
+    };
+}
diff --git a/include/elna/boot/name_analysis.h b/include/elna/boot/name_analysis.h
index f6663ea..9e10fab 100644
--- a/include/elna/boot/name_analysis.h
+++ b/include/elna/boot/name_analysis.h
@@ -36,7 +36,13 @@ namespace elna::boot
     class declaration_error final : public error
     {
     public:
-        enum class kind { undeclared_type, undeclared_trait, undeclared_symbol, local_export };
+        enum class kind
+        {
+            undeclared_type,
+            undeclared_trait,
+            undeclared_symbol,
+            local_export
+        };
         struct redefinition
         {
             std::optional<source_position> original;
@@ -57,17 +63,27 @@ namespace elna::boot
      * \c const qualifier used incorrectly — wrong position or
      * duplicate.
      */
-    class const_qualifier_error final : public error
+    class name_analysis_error final : public error
     {
     public:
-        enum class kind { array_position, duplicate };
+        enum class kind
+        {
+            array_position,
+            duplicate
+        };
+        struct not_initialized
+        {
+            std::vector<identifier> identifiers;
+        };
+        using payload_type = std::variant<not_initialized, kind>;
 
-        const_qualifier_error(const source_position position, kind error_kind);
+        name_analysis_error(const source_position position, payload_type payload);
+        std::optional<std::pair<std::string, source_position>> note() const override;
 
         std::string what() const override;
 
     private:
-        kind error_kind;
+        payload_type payload;
     };
 
     /**
@@ -95,17 +111,6 @@ namespace elna::boot
         payload_type payload;
     };
 
-    class not_initialized_error final : public error
-    {
-        std::vector<identifier> identifiers;
-
-    public:
-        not_initialized_error(const source_position position, std::vector<identifier> identifiers);
-
-        std::string what() const override;
-        std::optional<std::pair<std::string, source_position>> note() const override;
-    };
-
     /**
      * Origin of a field in a composite type.
      */
@@ -183,9 +188,6 @@ namespace elna::boot
     public:
         forward_table unresolved;
 
-        explicit declaration_visitor();
-
-        void visit(import_declaration *) override;
         void visit(unit *unit) override;
         void visit(type_declaration *declaration) override;
         void visit(procedure_declaration *declaration) override;
diff --git a/include/elna/boot/result.h b/include/elna/boot/result.h
index ee73f33..03d589e 100644
--- a/include/elna/boot/result.h
+++ b/include/elna/boot/result.h
@@ -273,40 +273,117 @@ namespace elna::boot
         integer_literal(const integer_literal& that);
         ~integer_literal();
 
+        /**
+         * \param that Summand.
+         * \return Sum of \c this and \p that, or \c nullopt on overflow.
+         */
         std::optional<integer_literal> add(const integer_literal& that) const;
+
+        /**
+         * \param that Subtrahend.
+         * \return Difference of \c this and \p that, or \c nullopt on overflow.
+         */
         std::optional<integer_literal> sub(const integer_literal& that) const;
+
+        /**
+         * \return Product of \c this and \p that, or \c nullopt on overflow.
+         */
         std::optional<integer_literal> mul(const integer_literal& that) const;
+
+        /**
+         * \param that Factor.
+         * \return Quotient of \c this and \p that, or \c nullopt if \p that is zero.
+         */
         std::optional<integer_literal> div(const integer_literal& that) const;
+
+        /**
+         * \param that Divisor.
+         * \return Remainder of \c this divided by \p that, or \c nullopt if \p that is zero.
+         */
         std::optional<integer_literal> mod(const integer_literal& that) const;
+
+        /**
+         * \return Arithmetic negation, or \c nullopt if unsigned or overflowing.
+         */
         std::optional<integer_literal> neg() const;
+
+        /**
+         * \return Signed negation of an unsigned magnitude, or \c nullopt on overflow.
+         */
+        std::optional<integer_literal> negate() const;
+
+        /**
+         * \param that Bit count.
+         * \return \c this shifted left by \p that bits, wrapping within the current size.
+         */
         std::optional<integer_literal> shl(const integer_literal& that) const;
+
+        /**
+         * \param that Bit count.
+         * \return \c this shifted right by \p that bits, or \c nullopt if the shift is out of range.
+         */
         std::optional<integer_literal> shr(const integer_literal& that) const;
 
+        /**
+         * \param that Operand.
+         * \return Bitwise OR of \c this and \p that.
+         */
         integer_literal operator|(const integer_literal& that) const;
+
+        /**
+         * \param that Operand.
+         * \return Bitwise AND of \c this and \p that.
+         */
         integer_literal operator&(const integer_literal& that) const;
+
+        /**
+         * \param that Operand.
+         * \return Bitwise XOR of \c this and \p that.
+         */
         integer_literal operator^(const integer_literal& that) const;
+
+        /**
+         * \return Bitwise complement of \c this.
+         */
         integer_literal operator~() const;
 
+        /**
+         * \param that Comparand.
+         * \return Whether \c this and \p that hold the same value.
+         */
         bool operator==(const integer_literal& that) const;
-        std::weak_ordering operator<=>(const integer_literal& that) const;
+
+        /// \overload
         template<typename U>
         bool operator==(U that) const
             requires(is_unsigned_v<U> && sizeof(U) <= sizeof(unsigned long int))
         {
             return mpz_cmp_ui(this->raw, that) == 0;
         }
+
+        /// \overload
         template<typename U>
         bool operator==(U that) const
             requires(is_signed_v<U> && sizeof(U) <= sizeof(signed long int))
         {
             return mpz_cmp_si(this->raw, that) == 0;
         }
+
+        /**
+         * \param that Comparand.
+         * \return Ordering of \c this relative to \p that.
+         */
+        std::weak_ordering operator<=>(const integer_literal& that) const;
+
+        /// \overload
         template<typename U>
         std::weak_ordering operator<=>(U that) const
             requires(is_unsigned_v<U> && sizeof(U) <= sizeof(unsigned long int))
         {
             return mpz_cmp_ui(this->raw, that) <=> 0;
         }
+
+        /// \overload
         template<typename U>
         std::weak_ordering operator<=>(U that) const
             requires(is_signed_v<U> && sizeof(U) <= sizeof(signed long int))
@@ -317,10 +394,21 @@ namespace elna::boot
         integer_literal& operator=(integer_literal&& that) noexcept;
         integer_literal& operator=(const integer_literal& that);
 
+        /// \return Whether the literal is signed.
         bool is_signed() const;
+
+        /// \return Storage size in bytes.
         std::size_t size() const;
+
+        /**
+         * \param base Base.
+         * \return String representation in the given \p base.
+         */
         std::string to_string(const std::uint8_t base = 10U) const;
 
+        /// \return Whether the stored value is negative.
+        bool is_negative() const;
+
         /**
          * Exports the stored value as a host \p T.
          *
@@ -359,10 +447,29 @@ namespace elna::boot
          * returned.
          *
          * \param target_size Size of the target type in bytes.
+         * \param target_signed Signedness of the target type.
          * \return Whether the value fits and has been changed.
          */
+        bool fit_into(bool target_signed, const std::size_t target_size);
+
+        /// \overload
         bool fit_into(const std::size_t target_size);
 
+        /**
+         * Cast the value to the given size and signedness, discarding bits if
+         * needed and reinterpreting bits on sign change.
+         *
+         * \param target_signed Result signedness.
+         * \param target_size Result size.
+         * \return Cast result.
+         */
+        integer_literal cast_to(bool target_signed, std::size_t target_size) const;
+
+        /**
+         * \tparam T Initializer type.
+         * \param initial Initial literal value.
+         * \return A literal constructed from the host value \p initial.
+         */
         template<typename T>
         static integer_literal from(T initial)
             requires is_integral<T>
@@ -374,6 +481,29 @@ namespace elna::boot
             return result;
         }
 
+        /**
+         * Constructs a literal of \p size bytes from \p initial inheriting its
+         * signedness.
+         *
+         * \tparam T Initializer type.
+         * \return A literal of \p size bytes constructed from \p initial, or \c nullopt on overflow.
+         */
+        template<typename T>
+        static std::optional<integer_literal> from(std::size_t size, T initial)
+            requires is_integral<T>
+        {
+            integer_literal result{ std::is_signed_v<T>, size };
+
+            mpz_import(result.raw, 1, 1, sizeof(T), 0, 0, &initial);
+
+            return std::move(result).check();
+        }
+
+        /**
+         * \param lhs Left hand side.
+         * \param lhs Right hand side.
+         * Swaps the contents of \p lhs and \p rhs.
+         */
         friend void swap(integer_literal& lhs, integer_literal& rhs) noexcept;
 
     private:
@@ -382,11 +512,9 @@ namespace elna::boot
         mpz_t raw;
 
         integer_literal(bool is_signed, std::size_t size);
-        bool fits_in(const std::size_t bits) const;
+        bool fits_in(bool starget_signed, const std::size_t bits) const;
         std::optional<integer_literal> check() &&;
-        bool is_negative() const;
         bool is_negative_minimum(const std::size_t bits) const;
-        bool is_negative_minimum() const;
         std::size_t bits() const;
 
         template<typename T>
@@ -474,9 +602,7 @@ namespace elna::boot
             }
         }
 
-        /**
-         * \overload
-         */
+        /// \overload
         const_iterator find(const key_type& key) const
         {
             auto search_result = this->index_map.find(key);
@@ -509,9 +635,7 @@ namespace elna::boot
             return { this->payload.begin() + insert_result.first->second, insert_result.second };
         }
 
-        /**
-         * \overload
-         */
+        /// \overload
         std::pair<iterator, bool> insert(const key_type& key, mapped_type&& value)
         {
             auto insert_result = this->index_map.emplace(key, this->payload.size());
@@ -532,9 +656,7 @@ namespace elna::boot
             return this->payload.begin();
         }
 
-        /**
-         * \overload
-         */
+        /// \overload
         const_iterator begin() const
         {
             return this->payload.cbegin();
@@ -550,9 +672,7 @@ namespace elna::boot
             return this->payload.end();
         }
 
-        /**
-         * \overload
-         */
+        /// \overload
         const_iterator end() const
         {
             return this->payload.cend();
@@ -577,9 +697,7 @@ namespace elna::boot
             return this->payload[this->index_map.find(key)->second].second;
         }
 
-        /**
-         * \overload
-         */
+        /// \overload
         const mapped_type& operator[](const key_type& key) const
         {
             return this->payload[this->index_map.find(key)->second].second;
@@ -605,13 +723,15 @@ namespace elna::boot
         std::size_t alignment;
     };
 
+    constexpr std::size_t target_integer_count = 5;
+
     /**
      * Target machine information, populated by the compiler backend glue layer.
      */
     struct target_info
     {
-        type_properties int_properties;
-        type_properties word_properties;
+        std::array<type_properties, target_integer_count> int_properties;
+        std::array<type_properties, target_integer_count> word_properties;
         type_properties pointer_properties;
         type_properties char_properties;
         type_properties float_properties;
diff --git a/include/elna/boot/symbol.h b/include/elna/boot/symbol.h
index bd07a7e..f048016 100644
--- a/include/elna/boot/symbol.h
+++ b/include/elna/boot/symbol.h
@@ -123,7 +123,7 @@ namespace elna::boot
         const std::string name;
         type referent;
 
-        explicit alias_type(const std::string& name);
+        explicit alias_type(const std::string& name, type referent = type());
     };
 
     struct pointer_type
@@ -158,8 +158,9 @@ namespace elna::boot
     struct primitive_type
     {
         const std::string identifier;
+        const type_properties properties;
 
-        explicit primitive_type(const std::string& identifier);
+        primitive_type(const std::string& identifier, const type_properties& properties);
     };
 
     struct record_type
@@ -243,9 +244,7 @@ namespace elna::boot
             return this->entries.begin();
         }
 
-        /**
-         * \overload
-         */
+        /// \overload
         const_iterator begin() const
         {
             return this->entries.cbegin();
@@ -261,9 +260,7 @@ namespace elna::boot
             return this->entries.end();
         }
 
-        /**
-         * \overload
-         */
+        /// \overload
         const_iterator end() const
         {
             return this->entries.cend();
@@ -405,7 +402,7 @@ namespace elna::boot
         std::shared_ptr<variable_info> is_variable() override;
     };
 
-    std::shared_ptr<symbol_table> builtin_symbol_table();
+    std::shared_ptr<symbol_table> builtin_symbol_table(const target_info& target);
 
     /**
      * Symbol bag contains:
@@ -520,9 +517,7 @@ namespace elna::boot
      */
     type resolve_underlying_type(const type& alias);
 
-    /**
-     * \overload
-     */
+    /// \overload
     type resolve_underlying_type(const std::shared_ptr<alias_type>& alias);
 
     /**
diff --git a/include/elna/boot/validation.h b/include/elna/boot/validation.h
index 4a256fa..171ac1d 100644
--- a/include/elna/boot/validation.h
+++ b/include/elna/boot/validation.h
@@ -49,7 +49,7 @@ namespace elna::boot
      * Validates:
      * - case label uniqueness
      */
-    class validation_visitor final : public walking_visitor, public error_container
+    class validation_visitor final : public empty_visitor, public error_container
     {
         symbol_bag& bag;
         evaluator constant_evaluator;
@@ -60,5 +60,14 @@ namespace elna::boot
         void visit(unit *unit) override;
         void visit(procedure_declaration *declaration) override;
         void visit(case_statement *statement) override;
+
+        void visit(assign_statement *) override;
+        void visit(if_statement *) override;
+        void visit(while_statement *) override;
+        void visit(repeat_statement *) override;
+        void visit(for_statement *) override;
+        void visit(defer_statement *) override;
+        void visit(empty_statement *) override;
+        void visit(procedure_call *) override;
     };
 }
diff --git a/include/elna/gcc/elna-builtins.h b/include/elna/gcc/elna-builtins.h
index 846a8db..9f24b00 100644
--- a/include/elna/gcc/elna-builtins.h
+++ b/include/elna/gcc/elna-builtins.h
@@ -27,6 +27,8 @@ along with GCC; see the file COPYING3.  If not see
 
 namespace elna::gcc
 {
+    const elna::boot::target_info& get_host_target();
+
     void init_ttree();
     std::shared_ptr<symbol_table> builtin_symbol_table();
 
diff --git a/include/elna/gcc/elna-tree.h b/include/elna/gcc/elna-tree.h
index 8f7e306..504b14c 100644
--- a/include/elna/gcc/elna-tree.h
+++ b/include/elna/gcc/elna-tree.h
@@ -60,8 +60,6 @@ namespace elna::gcc
     tree build_slice(tree slice_type, tree ptr, tree length);
     tree build_enumeration_type(const std::vector<std::string>& members);
 
-    const elna::boot::target_info& get_host_target();
-
     tree extract_constant(tree expression);
     tree constant_to_tree(const boot::constant_value& value,
             const std::shared_ptr<symbol_table>& symbols, tree type = NULL_TREE);
diff --git a/testsuite/fail_compilation/negative_integer_literal_overflow.elna b/testsuite/fail_compilation/negative_integer_literal_overflow.elna
new file mode 100644
index 0000000..7db4888
--- /dev/null
+++ b/testsuite/fail_compilation/negative_integer_literal_overflow.elna
@@ -0,0 +1,4 @@
+var
+  a: Int8 := -200i8 (* @Error Integer literal overflows *)
+
+end.
diff --git a/testsuite/runnable/fixed_int_max.elna b/testsuite/runnable/fixed_int_max.elna
new file mode 100644
index 0000000..0564dd6
--- /dev/null
+++ b/testsuite/runnable/fixed_int_max.elna
@@ -0,0 +1,6 @@
+begin
+  assert(#max(Int8) = 127i8);
+  assert(#max(Int16) = 32767i16);
+  assert(#max(Int32) = 2147483647i32);
+  assert(#max(Int64) = 9223372036854775807i64)
+end.
diff --git a/testsuite/runnable/fixed_int_min.elna b/testsuite/runnable/fixed_int_min.elna
new file mode 100644
index 0000000..de83d1a
--- /dev/null
+++ b/testsuite/runnable/fixed_int_min.elna
@@ -0,0 +1,6 @@
+begin
+  assert(#min(Int8) = -128i8);
+  assert(#min(Int16) = -32768i16);
+  assert(#min(Int32) = -2147483648i32);
+  assert(#min(Int64) = -9223372036854775808i64)
+end.
diff --git a/testsuite/runnable/fixed_word_max.elna b/testsuite/runnable/fixed_word_max.elna
new file mode 100644
index 0000000..76026a2
--- /dev/null
+++ b/testsuite/runnable/fixed_word_max.elna
@@ -0,0 +1,6 @@
+begin
+  assert(#max(Word8) = 255u8);
+  assert(#max(Word16) = 65535u16);
+  assert(#max(Word32) = 4294967295u32);
+  assert(#max(Word64) = 18446744073709551615u64)
+end.