توابع داخلی

const size = @sizeof(int32);
const line_num = @line();
const value = @cast(uint32, -1);

@debug() {
    // کدی که فقط در حالت اشکال‌زدایی کامپایل می‌شود
    const x = 10;
    printf("حالت اشکال‌زدایی\n");
}

@release() printf("نماد اختصاری حالت انتشار");

// همگی در زمان کامپایل ارزیابی می‌شوند
const type_size = @sizeof(int32);    // مقدار ۴ را برمی‌گرداند
const alignment = @alignof(float64); // مقدار ۸ را برمی‌گرداند
const current_line = @line();        // شماره خط را برمی‌گرداند
const current_file = @file_name();   // نام فایل را به صورت رشته برمی‌گرداند

// عملیات سطح پایین
@memcpy(&dest, &src, @sizeof(Data)); // کپی حافظه
@memset(&buffer, 0x00, 100);         // تنظیم حافظه
const x = @cast(uint32, y);          // تبدیل نوع

import std::libc{printf};

pub fn main() {
    printf("%s\n", @func_name()); // خروجی: main
}

struct Object {
    pub fn my_method() {
        printf("%s\n", @method_name()); // خروجی: my_method
    }
}

printf("%s\n", @module_name()); // خروجی: my_module_name

printf("%s\n", @file_name()); // خروجی: main.cyrus

printf("خطا در خط %d\n", @line()); // خروجی: خطا در خط ۵

printf("خطا در ستون %d\n", @column()); // خروجی: خطا در ستون ۱۰

printf("%d ", @sizeof(int32));   // ۴
printf("%d ", @sizeof(int64));   // ۸
printf("%d ", @sizeof(float64)); // ۸
printf("%d ", @sizeof(bool));    // ۱

// با انواع تعریف شده توسط کاربر نیز کار می‌کند
struct MyStruct { a: int32, b: int32 }
printf("%d\n", @sizeof(MyStruct)); // ۸

printf("%d ", @alignof(int32));                         // ۴
printf("%d ", @alignof(float64));                       // ۸
printf("%d ", @alignof(struct { a: int32* }));          // ۸
printf("%d\n", @alignof(struct { a: int32, b: int8 })); // ۴

struct Foo {
    a: int32,
    b: int32*
}

printf("%d ", @offsetof(Foo, "a"));  // ۰
printf("%d\n", @offsetof(Foo, "b")); // ۸

var x: @typeof('a'); // x از نوع char است
x = 'b';
printf("%c\n", x);   // خروجی: b

var y: @typeof(42);  // y از نوع int32 است

// تبدیل بین انواع عددی
var i8_val: int8 = 100;
var i32_val = @cast(int32, i8_val);  // ۱۰۰

// تبدیل بین علامت‌دار و بدون علامت
var u32_val: uint32 = 4294967295;
var i64_val = @cast(int64, u32_val); // ۴۲۹۴۹۶۷۲۹۵

// تبدیل کاراکتر به rune
type rune = uint32;
const x = @cast(rune, 'x'); // ۱۲۰

struct Data {
    id: int32,
    score: float64,
    flag: bool
}

var src = Data { id: 99, score: 99.5, flag: true };
var dst: Data;

@memcpy(&dst, &src, @sizeof(Data));
// اکنون dst شامل یک کپی از src است

var x: int32 = 0;
@memset(&x, 0xAAAA, @sizeof(int32));
// x اکنون برابر ۰xAAAAAAAA است

const x = 20;
@assert(x == 2, "x برابر ۲ نیست"); // با پیام باعث وحشت می‌شود

@panic("خطای فatal رخ داد"); // با پیام خاتمه می‌یابد

@todo("این تابع را پیاده‌سازی کنید"); // با پیام TODO باعث وحشت می‌شود

@unimplemented("هنوز پیاده‌سازی نشده است");

if (x) {
    // کاری انجام بده
} else {
    @unreachable("این شاخه هرگز نباید اجرا شود");
}

// شکل بلوک
@debug() {
    const x = 10;
    printf("حالت اشکال‌زدایی: %d\n", x);
}

// شکل دستور نماد اختصاری
@debug() printf("خروجی فقط در حالت اشکال‌زدایی\n");

// متغیرهای تعریف شده در داخل بلوک اشکال‌زدایی فقط در حالت اشکال‌زدایی در دسترس هستند
@debug() {
    const debug_var = 100;  // فقط در ساخت‌های اشکال‌زدایی وجود دارد
}
printf("%d\n", debug_var);  // در ساخت‌های انتشار خطا می‌دهد

// شکل بلوک
@release() {
    const x = 10;
    printf("حالت انتشار: %d\n", x);
}

// شکل دستور نماد اختصاری
@release() printf("خروجی فقط در حالت انتشار\n");