சுட்டி

Wave Explicit Memory Type Model

Wave இன் சுட்டி வடிவமைப்பு Wave வெளிப்படையான நினைவக வகை மாதிரி அடிப்படையிலானது. இந்த மாதிரியானது தொடரியல் தந்திரங்கள் அல்லது நூலக சுருக்கங்கள் என்று இல்லாமல், மொழி மட்டத்தில் வெளிப்படையான நினைவக வகைகளாக சுட்டிகள் மற்றும் வரிசைகளை வரையறுக்கும் நோக்கம் கொண்டது.

இந்த வடிவமைப்பின்படி, Wave ptr<T> இன் வகையாக சுட்டிக்காட்டி வெளிப்படுத்துகிறது. இது T என்ற குறிப்பிட்ட வகையின் மதிப்பைச் சேமிக்கும் நினைவக முகவரியைச் சுட்டிக்காட்டும் வகை என்பதை இது தெளிவாக வெளிப்படுத்துகிறது. இந்த அணுகுமுறை சுட்டிகளை ஆபரேட்டர்கள் அல்லது அறிவிப்பு தொடரியல் என்று இல்லாமல் வகை அமைப்பின் ஒரு பகுதியாகக் கருதுகிறது. நினைவக கட்டமைப்புகளை மிகவும் உள்ளுணர்வாகவும் தொடர்ந்து வெளிப்படுத்தவும் அனுமதிக்கிறது.

---

Wave இல், சுட்டிக்காட்டி என்பது ptr<T> வகையின் வெளிப்படையான வகையாகும். முகவரி பெறுவதற்கு & ஐயும், குறிப்புக்கு derefஐயும் பயன்படுத்தவும்.

பிரகடனம் மற்றும் துவக்கம்

var x: i32 = 10;
var p: ptr<i32> = &x;

சுட்டி வகைகளை உள்ளமைக்கலாம்.

var p1: ptr<i32> = &x;
var p2: ptr<ptr<i32>> = &p1;

பின்குறிப்பு

var x: i32 = 10;
var p: ptr<i32> = &x;

println("{}", deref p); // 10
deref p = 20;
println("{}", x);       // 20

null இலக்கிய விதி

null என்பது நியமன எழுத்து. இது ஒரு அடையாளங்காட்டி அல்ல, மாறி பெயராகப் பயன்படுத்த முடியாது.

முக்கிய விதிகள்:

• null இலக்குக்கு மட்டுமே ptr<T> ஒதுக்கப்படும்.
• i32, bool மற்றும் array<...> போன்ற சுட்டி அல்லாத வகைகளுக்கு இதை ஒதுக்க முடியாது.
• ஒரு முழு எண்ணைக் கொண்டு ஒரு சுட்டியை துவக்க முடியாது (0, 123, -1, முதலியன). null ஐ வெளிப்படையாகப் பயன்படுத்தவும்.

var p: ptr<i32> = null;
var arrp: ptr<array<i32, 3>> = null;

// var n: i32 = null;  // ERROR
// var b: bool = null; // ERROR

சுட்டி எண்கணிதம்

Wave பின்வரும் சுட்டி எண்கணிதத்தை ஆதரிக்கிறது:

• ptr + int: GEP அடிப்படையிலான சுட்டி முன்னேற்றம்
• int + ptr: அதே செயல்பாடு
• ptr - int: GEP அடிப்படையிலான சுட்டி பின்னோக்கி
• ptr - ptr: i64 பைட் வேறுபாட்டைக் கணக்கிடவும்

புள்ளிகள்:

• ptr<T> +/- n (T) அளவை அடிப்படையாகக் கொண்டு sizeof(T) நகரும்.
• வேறு வார்த்தைகளில் கூறுவதானால், ptr<i32> + 3 +12 பைட்டிற்கு நகர்கிறது.

var base: ptr<i32> = 0x1000 as ptr<i32>;

var p1: ptr<i32> = base + 3; // 0x1000 + 12
var p2: ptr<i32> = 2 + base; // 0x1000 + 8
var p3: ptr<i32> = base - 1; // 0x1000 - 4

var diff: i64 = p1 - base;   // 12 (byte diff)

சுட்டி ஒப்பீடு

ஒப்பிடுவதற்கு சுட்டிகள் பயன்படுத்தப்படலாம்.

if (p == null) { ... }
if (p != null) { ... }
if (p1 == p2) { ... }

வரிசைகளுடன் உறவு

சுட்டி வரிசை:

var a: i32 = 10;
var b: i32 = 20;
var arr: array<ptr<i32>, 2> = [&a, &b];
println("{} {}", deref arr[0], deref arr[1]);

வரிசை சுட்டி:

var p: ptr<array<i32, 3>> = &[1, 2, 3];
if (p != null) {
    println("{}", deref p[1]);
}

பாதுகாப்பு குறிப்புகள்

Wave ஆனது Rust போன்ற உரிமை/வாழ்நாள் அடிப்படையிலான சுட்டி பாதுகாப்பு மாதிரியை தற்போது கொண்டிருக்கவில்லை. எனவே, null dereferences தானாகவே தடுக்கப்படாது. deref க்கு முன் null ஐ வெளிப்படையாகச் சரிபார்க்கும் பேட்டர்னைப் பரிந்துரைக்கிறோம்.