ornekler/cekirdek/minimal-kernel/calisma/calisma_zamani.kbl

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at https://mozilla.org/MPL/2.0/.
#
# KabaLang yalın çalışma zamanı — KabaLang ile yazılmıştır.
#
# Yalın (çıplak donanım) derlemelere kendiliğinden eklenir. Buradaki
# `kaba_*` adlı işlevler, normal LLVM yolunda C++ çalışma zamanının verdiği
# C ABI işlevlerinin karşılığıdır; üreteç onları aynı adla dışa açar
# (işaretçiler burada 64 bit sayı olarak görünür). Böylece metin işlemleri
# (birleştirme, karşılaştırma, uzunluk, parça…) çekirdekte de normal
# KabaLang yazımıyla kullanılabilir.
#
# Yığın: `yigin_kur(adres, boyut)` ile çekirdeğin verdiği bölge. İlk uyan
# boş blok kullanılır, büyük blok bölünür; boş blok yoksa bölgenin
# sonundan ilerlenir. Bellek biterse işlemci durdurulur.
#
# Metin düzeni: [sayaç: 8][uzunluk (bayt): 8][baytlar][0]
#   sayaç < 0 → ölümsüz (derleme zamanında gömülen sabit metin).
#   Uzunluk ve indeks KOD NOKTASI üzerinden çalışır (UTF-8).

BASLIK = 16           # blok başlığı: [boyut][sonraki]
METIN_BASLIK = 16     # metin başlığı: [sayaç][uzunluk]

# Yığın durumu `yigin_durumu()` adresindedir (önyükleme parçasında 64 bayt).
BOS_LISTE = 0
KULLANILAN = 8
SINIR = 16
SON = 24

# ── yığın ────────────────────────────────────────────────────────────────
fonksiyon yigin_kur(adres, boyut):
    d = yigin_durumu()
    bellek_yaz64(d + BOS_LISTE, 0)
    bellek_yaz64(d + KULLANILAN, 0)
    bellek_yaz64(d + SINIR, adres)
    bellek_yaz64(d + SON, adres + boyut)

fonksiyon yigin_kullanilan():
    don bellek_oku64(yigin_durumu() + KULLANILAN)

fonksiyon kaba_ayir(n):
    d = yigin_durumu()
    boyut = bit_ve(n + 15, bit_degil(15)) + BASLIK
    onceki = 0
    blok = bellek_oku64(d + BOS_LISTE)
    iken blok != 0:
        bb = bellek_oku64(blok)
        eger bb >= boyut:
            eger bb - boyut >= 64:
                # Bloğun SONUNDAN kes; kalan parça listede kalır.
                bellek_yaz64(blok, bb - boyut)
                yeni = blok + bb - boyut
                bellek_yaz64(yeni, boyut)
                bellek_yaz64(d + KULLANILAN, bellek_oku64(d + KULLANILAN) + boyut)
                don yeni + BASLIK
            sonraki = bellek_oku64(blok + 8)
            eger onceki == 0:
                bellek_yaz64(d + BOS_LISTE, sonraki)
            degilse:
                bellek_yaz64(onceki + 8, sonraki)
            bellek_yaz64(d + KULLANILAN, bellek_oku64(d + KULLANILAN) + bb)
            don blok + BASLIK
        onceki = blok
        blok = bellek_oku64(blok + 8)
    sinir = bellek_oku64(d + SINIR)
    eger sinir == 0 veya sinir + boyut > bellek_oku64(d + SON):
        dur()
    bellek_yaz64(d + SINIR, sinir + boyut)
    bellek_yaz64(sinir, boyut)
    bellek_yaz64(d + KULLANILAN, bellek_oku64(d + KULLANILAN) + boyut)
    don sinir + BASLIK

fonksiyon kaba_serbest(p):
    eger p == 0:
        don 0
    d = yigin_durumu()
    blok = p - BASLIK
    bellek_yaz64(d + KULLANILAN, bellek_oku64(d + KULLANILAN) - bellek_oku64(blok))
    bellek_yaz64(blok + 8, bellek_oku64(d + BOS_LISTE))
    bellek_yaz64(d + BOS_LISTE, blok)
    don 0

# ── metin yardımcıları ───────────────────────────────────────────────────
fonksiyon bayt_uzunluk(m):
    don bellek_oku64(m + 8)

fonksiyon veri(m):
    don m + METIN_BASLIK

fonksiyon yeni_metin(n):
    m = kaba_ayir(METIN_BASLIK + n + 1)
    bellek_yaz64(m, 1)
    bellek_yaz64(m + 8, n)
    bellek_yaz8(m + METIN_BASLIK + n, 0)
    don m

fonksiyon kopyala(hedef, kaynak, n):
    dongu i icinde 0..n - 1:
        bellek_yaz8(hedef + i, bellek_oku8(kaynak + i))

fonksiyon devam_bayti_mi(b):
    don bit_ve(b, 0xC0) == 0x80

fonksiyon kod_noktasi_ofseti(m, k):
    # k. kod noktasının bayt ofseti; k uzunluğa eşitse bayt uzunluğu.
    n = bayt_uzunluk(m)
    i = 0
    sayac = 0
    iken i < n:
        eger degil devam_bayti_mi(bellek_oku8(veri(m) + i)):
            eger sayac == k:
                don i
            sayac = sayac + 1
        i = i + 1
    don n

fonksiyon alt_metin(m, bas, son):
    # [bas, son) bayt aralığından yeni metin.
    r = yeni_metin(son - bas)
    kopyala(veri(r), veri(m) + bas, son - bas)
    don r

# ── C ABI karşılıkları (normal yolda kaba_rt.cpp) ────────────────────────
fonksiyon kaba_m_tut(m):
    eger m != 0 ve bellek_oku64(m) >= 0:
        bellek_yaz64(m, bellek_oku64(m) + 1)

fonksiyon kaba_m_birak(m):
    eger m == 0:
        don 0
    s = bellek_oku64(m)
    eger s > 0:
        eger s == 1:
            kaba_serbest(m)
        degilse:
            bellek_yaz64(m, s - 1)
    don 0

fonksiyon kaba_m_sabit(p, n):
    r = yeni_metin(n)
    kopyala(veri(r), p, n)
    don r

fonksiyon kaba_m_cden(p):
    n = 0
    iken bellek_oku8(p + n) != 0:
        n = n + 1
    don kaba_m_sabit(p, n)

fonksiyon kaba_m_birlestir(a, b):
    la = bayt_uzunluk(a)
    lb = bayt_uzunluk(b)
    r = yeni_metin(la + lb)
    kopyala(veri(r), veri(a), la)
    kopyala(veri(r) + la, veri(b), lb)
    don r

fonksiyon kaba_m_birlestir_tasi(a, b):
    # Sol taraf geçicidir: sonuç üretilir, sol bırakılır.
    r = kaba_m_birlestir(a, b)
    kaba_m_birak(a)
    don r

fonksiyon kaba_m_karsilastir(a, b):
    la = bayt_uzunluk(a)
    lb = bayt_uzunluk(b)
    n = la
    eger lb < n:
        n = lb
    dongu i icinde 0..n - 1:
        x = bellek_oku8(veri(a) + i)
        y = bellek_oku8(veri(b) + i)
        eger x < y:
            don 0 - 1
        eger x > y:
            don 1
    eger la < lb:
        don 0 - 1
    eger la > lb:
        don 1
    don 0

fonksiyon kaba_m_esit(a, b):
    eger bayt_uzunluk(a) != bayt_uzunluk(b):
        don 0
    eger kaba_m_karsilastir(a, b) == 0:
        don 1
    don 0

fonksiyon kaba_m_uzunluk(m):
    n = bayt_uzunluk(m)
    sayac = 0
    dongu i icinde 0..n - 1:
        eger degil devam_bayti_mi(bellek_oku8(veri(m) + i)):
            sayac = sayac + 1
    don sayac

fonksiyon kaba_m_bos_mu(m):
    eger bayt_uzunluk(m) == 0:
        don 1
    don 0

fonksiyon kaba_m_sayidan(n):
    eksi = n < 0
    eger eksi:
        n = 0 - n
    basamak = 1
    b = n
    iken b >= 10:
        b = b // 10
        basamak = basamak + 1
    uzun = basamak
    eger eksi:
        uzun = uzun + 1
    r = yeni_metin(uzun)
    eger eksi:
        bellek_yaz8(veri(r), 0x2D)
    k = uzun - 1
    dongu j icinde 1..basamak:
        bellek_yaz8(veri(r) + k, 0x30 + n % 10)
        n = n // 10
        k = k - 1
    don r

fonksiyon kaba_m_sayiya(m):
    n = bayt_uzunluk(m)
    i = 0
    eksi = yanlis
    eger n > 0 ve bellek_oku8(veri(m)) == 0x2D:
        eksi = dogru
        i = 1
    sonuc = 0
    iken i < n:
        c = bellek_oku8(veri(m) + i)
        eger c < 0x30 veya c > 0x39:
            don 0
        sonuc = sonuc * 10 + (c - 0x30)
        i = i + 1
    eger eksi:
        don 0 - sonuc
    don sonuc

fonksiyon kaba_m_mantiktan(b):
    eger b != 0:
        don kaba_m_cden(veri_adresi("doğru"))
    don kaba_m_cden(veri_adresi("yanlış"))

fonksiyon kaba_m_oge(m, i, satir):
    n = kaba_m_uzunluk(m)
    eger i < 0:
        i = i + n
    eger i < 0 veya i >= n:
        dur()
    don alt_metin(m, kod_noktasi_ofseti(m, i), kod_noktasi_ofseti(m, i + 1))

fonksiyon kaba_m_parca(m, bas, uzunluk):
    n = kaba_m_uzunluk(m)
    eger bas < 0:
        bas = 0
    eger bas > n:
        bas = n
    son = n
    eger uzunluk >= 0 ve bas + uzunluk < n:
        son = bas + uzunluk
    don alt_metin(m, kod_noktasi_ofseti(m, bas), kod_noktasi_ofseti(m, son))

fonksiyon kaba_m_ile_baslar(m, onek):
    lo = bayt_uzunluk(onek)
    eger lo > bayt_uzunluk(m):
        don 0
    dongu i icinde 0..lo - 1:
        eger bellek_oku8(veri(m) + i) != bellek_oku8(veri(onek) + i):
            don 0
    don 1

fonksiyon bayt_bul(m, parca):
    lm = bayt_uzunluk(m)
    lp = bayt_uzunluk(parca)
    eger lp == 0:
        don 0
    i = 0
    iken i + lp <= lm:
        tutar = dogru
        j = 0
        iken tutar ve j < lp:
            eger bellek_oku8(veri(m) + i + j) != bellek_oku8(veri(parca) + j):
                tutar = yanlis
            j = j + 1
        eger tutar:
            don i
        i = i + 1
    don 0 - 1

fonksiyon kaba_m_icerir(m, parca):
    eger bayt_bul(m, parca) >= 0:
        don 1
    don 0

fonksiyon kaba_m_bul(m, parca):
    b = bayt_bul(m, parca)
    eger b < 0:
        don 0 - 1
    # bayt ofsetinden kod noktası dizinine
    sayac = 0
    dongu i icinde 0..b - 1:
        eger degil devam_bayti_mi(bellek_oku8(veri(m) + i)):
            sayac = sayac + 1
    don sayac

fonksiyon kaba_m_tekrarla(m, n):
    l = bayt_uzunluk(m)
    eger n < 0:
        n = 0
    r = yeni_metin(l * n)
    dongu k icinde 0..n - 1:
        kopyala(veri(r) + k * l, veri(m), l)
    don r