Tonyukuk Belgeleri

Türkçe sözdizimi ile derlenen programlama dili — tam referans.

Kurulum

Tonyukuk derleyicisini kurmak için aşağıdaki adımları izleyin.

Gereksinimler

GCC (veya Clang) — C11 destekli bir C derleyicisi
LLVM 17 — LLVM backend ve WASM desteği için
make — Derleme sistemi
lld-17 — WebAssembly bağlayıcı (isteğe bağlı)
wabt — WAT/WASM dönüşüm araçları (isteğe bağlı)

Linux’ta Derleme

# Gerekli paketleri yükleyin (Debian/Ubuntu)
$ sudo apt update
$ sudo apt install gcc make llvm-17-dev lld-17 wabt

# Kaynak kodu indirin
$ git clone https://github.com/tonyukuk/tonyukuk.git
$ cd tonyukuk

# Derleyin
$ make

# Sisteme kurun (isteğe bağlı)
$ sudo make install

Kurulumdan sonra tonyukuk-derle komutu terminalde kullanılabilir olacaktır.

VS Code Eklentisi

Tonyukuk, VS Code için bir eklenti sunar. Eklenti sözdizimi renklendirme, otomatik tamamlama ve hata gösterimi sağlar.

VS Code’u açın ve Eklentiler (Extensions) panelini açın (Ctrl+Shift+X)
“Tonyukuk” aratın ve eklentiyi yükleyin
Eklenti otomatik olarak .tr dosyalarını tanıyacak ve renklendirme yapacaktır

İpucu: Eklenti, arka planda Tonyukuk LSP sunucusunu (tonyukuk-lsp) kullanır. LSP sunucusu kuruluysa otomatik tamamlama ve anlık hata tespiti de etkinleşir.

İlk Program

Her programlama dilinin geleneği olduğu gibi, ilk programımız ekrana “Merhaba Dünya!” yazdıracak.

1. Dosya Oluşturma

Favori metin düzenleyicinizi açın ve merhaba.tr adında yeni bir dosya oluşturun:

# merhaba.tr
yazdır("Merhaba Dünya!")

2. Derleme ve Çalıştırma

# Kaynak kodu derle
$ tonyukuk-derle merhaba.tr -o merhaba

# Çalıştır
$ ./merhaba
Merhaba Dünya!

3. Ne Oldu?

yazdır() — Tonyukuk’un yerleşik yazdırma fonksiyonudur. Parametreyi konsola yazar ve yeni satıra geçer.
"Merhaba Dünya!" — Çift tırnak içinde bir metin (string) değeridir.
tonyukuk-derle merhaba.tr -o merhaba — merhaba.tr dosyasını derler ve merhaba adlı çalıştırılabilir dosya üretir.

İpucu: LLVM backend ile derlemek için --backend=llvm bayrağını ekleyin. JIT modu ile dosya üretmeden doğrudan çalıştırmak için --jit kullanın:
tonyukuk-derle --backend=llvm --jit merhaba.tr

Temel Kavramlar

Bu bölümde Tonyukuk programlama dilinin temel yapı taşlarını öğreneceksiniz.

Değişkenler ve Veri Tipleri

Tonyukuk’ta beş temel veri tipi vardır:

# Tamsayı (tam)
tam yas = 25

# Ondalık sayı (ondalık)
ondalık sicaklik = 36.6

# Metin (metin)
metin isim = "Tonyukuk"

# Mantıksal (mantık)
mantık aktif = doğru

# Tip çıkarımlı değişken
değişken sayi = 42        # derleyici tipi otomatik çıkarır
sabit PI = 3.14159        # değiştirilemez sabit

Fonksiyonlar (İşlevler)

Fonksiyonlar işlev anahtar kelimesi ile tanımlanır ve son ile biter:

işlev selamla(isim: metin) -> metin
    döndür "Merhaba, " + isim + "!"
son

yazdır(selamla("Dünya"))  # Merhaba, Dünya!

# Birden fazla parametre ve tamsayı dönüşü
işlev topla(a: tam, b: tam) -> tam
    döndür a + b
son

yazdır(topla(3, 5))  # 8

Kontrol Akışı

Koşullar eğer/yoksa, döngüler döngü ve iken anahtar kelimeleri ile yazılır:

# Koşullu ifade
tam puan = 85

eğer puan >= 90 ise
    yazdır("Pekiyi")
yoksa eğer puan >= 70 ise
    yazdır("İyi")
yoksa
    yazdır("Geliştirmeli")
son

# Sayma döngüsü
döngü i = 1, 5 ise
    yazdır(i)
son

# Koşullu döngü
tam sayac = 10
iken sayac > 0 ise
    yazdır(sayac)
    sayac -= 1
son

Mini Proje: Basit Hesap Makinesi

Öğrendiğimiz kavramları birleştirerek basit bir hesap makinesi yazalım. Bu program kullanıcıdan iki sayı ve bir işlem alarak sonuç hesaplar.

# hesap_makinesi.tr — Basit hesap makinesi
kullan sistem

işlev hesapla(a: tam, b: tam, islem: metin) -> tam
    eğer islem == "topla" ise
        döndür a + b
    son
    eğer islem == "cikar" ise
        döndür a - b
    son
    eğer islem == "carp" ise
        döndür a * b
    son
    eğer islem == "bol" ise
        eğer b == 0 ise
            yazdır("Hata: Sıfıra bölünemez!")
            döndür 0
        son
        döndür a / b
    son
    yazdır("Bilinmeyen işlem!")
    döndür 0
son

# Kullanım örnekleri
yazdır(hesapla(10, 5, "topla"))   # 15
yazdır(hesapla(10, 5, "cikar"))   # 5
yazdır(hesapla(10, 5, "carp"))    # 50
yazdır(hesapla(10, 5, "bol"))     # 2

# Derleme ve çalıştırma
$ tonyukuk-derle hesap_makinesi.tr -o hesap
$ ./hesap
15
5
50
2

Sonraki Adımlar: Temel kavramları öğrendiniz. Şimdi aşağıdaki bölümlerde sınıflar, modüller, hata yönetimi ve daha fazlasını keşfedebilirsiniz. Ayrıca çevrimiçi playground’da kod yazarak pratik yapabilirsiniz.

Giriş

Tonyukuk, tamamen Türkçe anahtar kelimeler ve fonksiyon isimleri kullanan, x86-64, ARM64 ve WebAssembly hedeflerine derlenen bir programlama dilidir.

Derleyici C11 ile yazılmıştır. Dört backend sunar:

Native Backend: Bağımsız çalışır, x86_64 ve ARM64 assembly üretir
LLVM Backend: LLVM 17 altyapısı ile çoklu platform desteği, JIT derleme, gelişmiş optimizasyonlar ve DWARF debug bilgisi
WASM Backend (LLVM): LLVM üzerinden WebAssembly binary (.wasm) üretir — tarayıcıda doğrudan çalışır
WASM Backend (Native): WAT (WebAssembly Text Format) üretir

Ayrıca çevrimiçi playground sayesinde tarayıcınızdan kod yazıp anında çalıştırabilirsiniz. WASM modu ile derlenen kod tarayıcınızda yerel olarak çalışır.

İlk Program

# merhaba.tr
yazdır("Merhaba Dünya!")

Derleme ve çalıştırma:

$ tonyukuk-derle merhaba.tr -o merhaba
$ ./merhaba
Merhaba Dünya!

Veri Tipleri

Tip	Açıklama	Örnek
`tam`	64-bit işaretli tamsayı	`42`, `-7`
`ondalık`	64-bit kayan nokta (double)	`3.14`, `-0.5`
`metin`	UTF-8 karakter dizisi	`"Merhaba"`
`mantık`	Boolean	`doğru`, `yanlış`
`dizi`	Dinamik dizi	`[1, 2, 3]`
`küme`	Küme (set)	`küme_yeni()`
`boş`	Boş/null değer	`boş`

Değişkenler

# Tip belirterek
tam sayi = 42
ondalık pi = 3.14
metin ad = "Tonyukuk"
mantık aktif = doğru

# Tip çıkarımlı
değişken x = 10
sabit PI = 3.14159

Operatörler

Aritmetik

+ - * / % — Toplama, çıkarma, çarpma, bölme, mod

Karşılaştırma

== != < > <= >=

Mantıksal

ve veya değil

Bit Düzeyi

& | ^ ~ << >>

Atama

= += -= *= /= %= := (walrus)

Özel

|> pipe, .. aralık, ... spread/rest, ?? null birleşim

Koşul: eğer / yoksa

eğer x > 0 ise
    yazdır("Pozitif")
yoksa
    yazdır("Negatif veya sıfır")
son

Döngü

Sayma döngüsü

döngü i = 0, 10 ise
    yazdır(i)
son

Koşullu döngü (iken)

iken x > 0 ise
    x -= 1
son

Her/için (foreach)

her eleman için dizi ise
    yazdır(eleman)
son

kır ile döngüden çıkılır, devam ile sonraki iterasyona geçilir.

Eşle / Durum (Switch)

eşle puan / 10 ise
    durum 9:
        yazdır("Pekiyi")
    durum 8:
        yazdır("İyi")
    varsayılan:
        yazdır("Diğer")
son

İşlev Tanımı

işlev topla(a: tam, b: tam) -> tam
    döndür a + b
son

# Rekürsif
işlev faktöriyel(n: tam) -> tam
    eğer n <= 1 ise
        döndür 1
    son
    döndür n * faktöriyel(n - 1)
son

Lambda ve Closure

# Lambda ifadesi
değişken kare = işlev(x: tam) -> tam
    döndür x * x
son

yazdır(kare(5))  # 25

Sınıflar

sınıf Nokta
    tam x
    tam y

    işlev mesafe() -> tam
        döndür bu.x * bu.x + bu.y * bu.y
    son
son

Nokta p = Nokta(3, 4)
yazdır(p.mesafe())  # 25

Kalıtım

sınıf Hayvan
    metin isim
    işlev tanıt() -> metin
        döndür bu.isim
    son
son

sınıf Kedi : Hayvan
    işlev miyavla() -> metin
        döndür "Miyav!"
    son
son

Arayüz

arayüz Cizim
    çiz() -> tam
son

sınıf Kare uygula Cizim
    işlev çiz() -> tam
        döndür 1
    son
son

Hata Yönetimi

dene
    fırlat "Bir hata oluştu!"
yakala hata
    yazdır(hata)
son

fırlat ile hata fırlatılır, dene/yakala ile yakalanır. sonunda bloğu isteğe bağlıdır.

Modüller

Modüller kullan anahtar kelimesi ile içe aktarılır:

kullan matematik
kullan zaman

yazdır(sin(pi() / 2))
yazdır(yıl())

matematik

Trigonometri, logaritma, matris, istatistik ve sayı teorisi fonksiyonları.

Temel

Fonksiyon	Dönüş	Açıklama
`mutlak(x: tam)`	tam	Mutlak değer
`kuvvet(x: tam, y: tam)`	tam	Üs alma (tamsayı)
`karekök(x: ondalık)`	ondalık	Karekök
`min(x: tam, y: tam)`	tam	Minimum
`maks(x: tam, y: tam)`	tam	Maksimum
`mod(x: tam, y: tam)`	tam	Modülo
`işaret(x: tam)`	tam	İşaret (-1, 0, 1)
`rastgele(maks: tam)`	tam	0..maks arası rastgele
`pi()`	ondalık	Pi sabiti
`e()`	ondalık	Euler sabiti

Trigonometri

Fonksiyon	Dönüş	Açıklama
`sin(x)`, `cos(x)`, `tan(x)`	ondalık	Temel trig.
`asin(x)`, `acos(x)`, `atan(x)`	ondalık	Ters trig.
`atan2(y, x)`	ondalık	2 argümanlı atan
`sinh(x)`, `cosh(x)`, `tanh(x)`	ondalık	Hiperbolik

Logaritma ve Üstel

Fonksiyon	Dönüş	Açıklama
`log(x)`	ondalık	Doğal logaritma
`log10(x)`, `log2(x)`	ondalık	Log tabanı 10/2
`üstel(x)`	ondalık	e^x
`üst(x, y)`	ondalık	x^y (ondalık)
`küpkök(x)`	ondalık	Küpkök
`hipot(x, y)`	ondalık	Hipotanüs

Yuvarlama

Fonksiyon	Açıklama
`taban(x)`	Aşağı yuvarlama (floor)
`tavan(x)`	Yukarı yuvarlama (ceiling)
`yuvarla(x)`	En yakına yuvarlama (round)
`buda(x)`	Kesme (truncate)

Tamsayı Fonksiyonları

Fonksiyon	Açıklama
`faktöriyel(n)`	n!
`obeb(a, b)`	OBEB (GCD)
`okek(a, b)`	OKEK (LCM)
`kombinasyon(n, k)`	C(n, k)
`permütasyon(n, k)`	P(n, k)

İstatistik

Fonksiyon	Açıklama
`toplam(d: dizi)`	Toplam
`ortalama(d: dizi)`	Aritmetik ortalama
`medyan(d: dizi)`	Medyan
`varyans(d: dizi)`	Varyans
`std_sapma(d: dizi)`	Standart sapma
`en_küçük(d: dizi)`	Minimum eleman
`en_büyük(d: dizi)`	Maksimum eleman
`korelasyon(x, y)`	Korelasyon katsayısı

Matris

Fonksiyon	Açıklama
`matris(satır, sütun)`	Sıfır matris oluştur
`matris_birim(n)`	Birim matris
`matris_topla(a, b)`	Matris toplama
`matris_çıkar(a, b)`	Matris çıkarma
`matris_çarp(a, b)`	Matris çarpma
`matris_skaler(a, k)`	Skaler çarpım
`matris_transpoz(a)`	Transpoz
`matris_determinant(a)`	Determinant
`matris_ters(a)`	Ters matris
`matris_oku(m, i, j)`	Eleman oku
`matris_yaz(m, i, j, v)`	Eleman yaz
`matris_iz(a)`	İz (trace)

Polinom ve Nümerik

Fonksiyon	Açıklama
`polinom_hesapla(k, x)`	Polinom değer hesapla
`polinom_türev(k)`	Türev katsayıları
`polinom_integral(k)`	İntegral katsayıları
`sayısal_integral(x, y)`	Trapez yöntemi
`lineer_regresyon(x, y)`	Doğrusal regresyon

Doğrulama

Fonksiyon	Açıklama
`sonsuz_mu(x)`	Sonsuz mu?
`sayidegil_mi(x)`	NaN mı?

metin

Metin (string) işleme fonksiyonları.

Fonksiyon	Dönüş	Açıklama
`büyük_harf(m)`	metin	Tümünü büyük harfe çevir
`küçük_harf(m)`	metin	Tümünü küçük harfe çevir
`harf_buyut(m)`	metin	Büyük harfe çevir (inline)
`harf_kucult(m)`	metin	Küçük harfe çevir (inline)
`kes(m, baş, uzunluk)`	metin	Alt metin çıkar
`bul(m, aranan)`	tam	İlk indeks (-1 = bulunamadı)
`içerir(m, aranan)`	mantık	İçeriyor mu?
`kırp(m)`	metin	Baş/son boşlukları sil
`tersle(m)`	metin	Metni ters çevir
`tekrarla(m, kez)`	metin	Metin tekrarlama
`başlar_mi(m, önek)`	mantık	Önekle mi başlıyor?
`biter_mi(m, sonek)`	mantık	Sonekle mi bitiyor?
`değiştir(m, eski, yeni)`	metin	Değiştir
`böl(m, ayırıcı)`	dizi	Böl
`birleştir_metin(d, ayırıcı)`	metin	Birleştir (join)
`dosya_satırlar(dosya)`	dizi	Dosya satırlarını oku
`dosya_ekle(dosya, içerik)`	tam	Dosyaya ekle (append)

Sözlük fonksiyonları da bu modülle gelir:

Fonksiyon	Açıklama
`sözlük_yeni()`	Yeni sözlük oluştur
`sözlük_ekle(s, anahtar, değer)`	Eleman ekle
`sözlük_oku(s, anahtar)`	Eleman oku
`sözlük_uzunluk(s)`	Uzunluk
`sözlük_var_mı(s, anahtar)`	Anahtar var mı?
`sözlük_sil(s, anahtar)`	Anahtar sil

dizi

Dizi (array) işlemleri.

Fonksiyon	Açıklama
`sırala(d)`	Küçükten büyüğe sırala
`ekle(d, eleman)`	Sona eleman ekle
`çıkar(d)`	Son elemanı çıkar
`birleştir(d1, d2)`	İki diziyi birleştir

sistem

Dosya I/O ve tip dönüşüm fonksiyonları.

Fonksiyon	Dönüş	Açıklama
`satiroku()`	metin	Konsoldan satır oku
`dosya_oku(yol)`	metin	Dosya içeriği oku
`dosya_yaz(yol, içerik)`	tam	Dosyaya yaz
`tam_metin(s)`	metin	Tamsayıyı metne çevir
`ondalık_metin(s)`	metin	Ondalığı metne çevir
`metin_tam(m)`	tam	Metni tamsayıya çevir
`metin_ondalık(m)`	ondalık	Metni ondalığa çevir

zaman

Fonksiyon	Dönüş	Açıklama
`şimdi()`	tam	Unix zaman damgası
`yıl()`	tam	Yıl
`ay()`	tam	Ay (1-12)
`gün()`	tam	Gün (1-31)
`saat()`	tam	Saat (0-23)
`dakika()`	tam	Dakika (0-59)
`saniye()`	tam	Saniye (0-59)
`tarih_metin()`	metin	Tarih/saat dizisi

json

Fonksiyon	Dönüş	Açıklama
`json_çözümle(m)`	tam	JSON metnini sözlüğe çözümle
`json_oluştur(s)`	metin	Sözlüğü JSON metnine dönüştür

kripto

Fonksiyon	Dönüş	Açıklama
`md5(m)`	metin	MD5 özütü
`sha256(m)`	metin	SHA-256 özütü
`base64_kodla(m)`	metin	Base64 kodla
`base64_çöz(m)`	metin	Base64 çöz

ağ

Fonksiyon	Dönüş	Açıklama
`http_al(url)`	metin	HTTP GET isteği
`http_gönder(url, veri)`	metin	HTTP POST isteği

düzeni (regex)

Fonksiyon	Dönüş	Açıklama
`eşleşir_mi(metin, desen)`	mantık	Regex eşleşiyor mu?
`eşleşme_bul(metin, desen)`	metin	İlk eşleşme
`tüm_eşleşmeler(metin, desen)`	dizi	Tüm eşleşmeler

paralel

Fonksiyon	Dönüş	Açıklama
`iş_oluştur(fn)`	tam	Yeni iş parçacığı oluştur
`iş_bekle(handle)`	tam	İş parçacığını bekle
`kilit_oluştur()`	tam	Mutex oluştur
`kilitle(kilit)`	—	Kilitle
`kilit_bırak(kilit)`	—	Kilidi bırak

soket

Fonksiyon	Dönüş	Açıklama
`soket_oluştur()`	tam	TCP soket oluştur
`soket_bağlan(fd, adres, port)`	mantık	Sunucuya bağlan
`soket_dinle(port)`	tam	Portta dinle
`soket_kabul(fd)`	tam	Bağlantı kabul et
`soket_gönder(fd, veri)`	tam	Veri gönder
`soket_al(fd)`	metin	Veri al
`soket_kapat(fd)`	—	Soketi kapat

küme

Fonksiyon	Dönüş	Açıklama
`küme_yeni()`	tam	Boş küme oluştur
`küme_ekle(kume, değer)`	—	Eleman ekle
`küme_sil(kume, değer)`	—	Eleman sil
`küme_var_mı(kume, değer)`	mantık	Eleman var mı?
`küme_uzunluk(kume)`	tam	Eleman sayısı
`küme_birleşim(a, b)`	tam	Birleşim kümesi
`küme_kesişim(a, b)`	tam	Kesişim kümesi
`küme_fark(a, b)`	tam	Fark kümesi
`küme_yazdır(kume)`	—	Kümeyi yazdır

veritabanı

Fonksiyon	Dönüş	Açıklama
`vt_aç(yol)`	tam	SQLite veritabanı aç
`vt_çalıştır(db, sql)`	tam	SQL komutu çalıştır
`vt_sorgula(db, sql)`	metin	SQL sorgusu çalıştır
`vt_kapat(db)`	—	Veritabanını kapat

ortam

Fonksiyon	Dönüş	Açıklama
`ortam_al(anahtar)`	metin	Çevre değişkeni oku
`ortam_koy(anahtar, değer)`	—	Çevre değişkeni yaz
`ortam_sil(anahtar)`	—	Çevre değişkeni sil
`ortam_hepsi()`	dizi	Tüm çevre değişkenleri

argüman

Fonksiyon	Dönüş	Açıklama
`argüman_sayısı()`	tam	Argüman sayısı
`argüman_al(indeks)`	metin	Argümanı al
`argüman_hepsi()`	dizi	Tüm argümanlar

tekrarlayıcı

Fonksiyon	Dönüş	Açıklama
`zincir(d1, d2)`	dizi	İki diziyi zincirle
`tekrarla_dizi(d, kez)`	dizi	Diziyi kez kere tekrarla
`parçala(d, boyut)`	dizi	Diziyi parçalara böl
`permütasyonlar(d)`	dizi	Permütasyonlar
`kombinasyonlar(d, r)`	dizi	Kombinasyonlar
`düz(d)`	dizi	İç içe diziyi düzleştir

çekirdek (otomatik yüklü)

Bu fonksiyonlar kullan gerektirmeden her zaman kullanılabilir.

Fonksiyon	Dönüş	Açıklama
`yazdır(değer)`	—	Konsola yazdır
`uzunluk(d: dizi)`	tam	Dizi uzunluğu
`metin_uzunluk(m: metin)`	tam	Metin uzunluğu
`eşlem(d, fn)`	dizi	Map: her elemana uygula
`filtre(d, fn)`	dizi	Koşula uyanları tut
`indirge(d, fn, başlangıç)`	tam	Sola katlama (reduce)
`biçimle(format, değer)`	metin	Biçimlendirilmiş metin
`numarala(d)`	dizi	Enumerate: [indeks, değer]
`eşleştir(d1, d2)`	dizi	Zip: [a, b] çiftleri
`ters(d)`	dizi	Diziyi ters çevir
`dilimle(d, baş, bitiş)`	dizi	Dilim (slice)
`doğrula(koşul)`	—	Test assertion

donanım

Gömülü sistemler (Arduino, ESP32, Raspberry Pi Pico) için donanım soyutlama modülü. GPIO, PWM, ADC, I2C, SPI, UART ve zamanlama fonksiyonları sunar.

kullan donanım

GPIO (Genel Amaçlı Giriş/Çıkış)

Fonksiyon	Dönüş	Açıklama
`pin_modu(pin: tam, mod: tam)`	—	Pin modunu ayarla: GIRIS=0, CIKIS=1, GIRIS_PULLUP=2
`dijital_yaz(pin: tam, deger: tam)`	—	Pin’e dijital değer yaz: DUSUK=0, YUKSEK=1
`dijital_oku(pin: tam)`	tam	Pin’den dijital değer oku (0 veya 1)
`analog_oku(pin: tam)`	tam	Analog değer oku (0-1023 arası, 10-bit ADC)

PWM (Darbe Genişlik Modülasyonu)

Fonksiyon	Dönüş	Açıklama
`pwm_baslat(pin: tam)`	—	PWM kanalını başlat
`pwm_yaz(pin: tam, deger: tam)`	—	PWM duty cycle yaz (0-255)

I2C / SPI

Fonksiyon	Dönüş	Açıklama
`i2c_baslat(hiz: tam)`	—	I2C başlat (100=100kHz, 400=400kHz)
`i2c_yaz(adres: tam, veri: tam)`	tam	I2C cihazına veri yaz, başarı için 0 döndürür
`i2c_oku(adres: tam)`	tam	I2C cihazından veri oku
`spi_baslat(hiz: tam)`	—	SPI başlat (hız kHz cinsinden)
`spi_aktar(veri: tam)`	tam	SPI üzerinden veri gönder ve al (full-duplex)

UART (Seri Port)

Fonksiyon	Dönüş	Açıklama
`seri_baslat(baud: tam)`	—	Seri portu başlat (örn: 9600, 115200)
`seri_yaz(metin: metin)`	—	Seri porta metin yaz
`seri_oku()`	tam	Seri porttan bir byte oku (bloke eder)
`seri_hazir_mi()`	tam	Okunacak veri var mı kontrol et

Zamanlama ve Kesme

Fonksiyon	Dönüş	Açıklama
`bekle_ms(ms: tam)`	—	Belirtilen milisaniye kadar bekle
`bekle_us(us: tam)`	—	Belirtilen mikrosaniye kadar bekle
`milis()`	tam	Program başlangıcından bu yana geçen milisaniye
`mikros()`	tam	Program başlangıcından bu yana geçen mikrosaniye
`kesme_ac()`	—	Global kesmeleri etkinleştir
`kesme_kapat()`	—	Global kesmeleri devre dışı bırak

Örnek: LED Yakıp Söndürme

kullan donanım

# LED pin 13’e bağlı
pin_modu(13, 1)  # CIKIS modu

iken doğru ise
    dijital_yaz(13, 1)  # LED aç
    bekle_ms(1000)
    dijital_yaz(13, 0)  # LED kapat
    bekle_ms(1000)
son

dosya

Kapsamlı dosya sistemi işlemleri: okuma, yazma, dizin yönetimi, yol işlemleri ve daha fazlası.

kullan dosya

Okuma / Yazma

Fonksiyon	Dönüş	Açıklama
`dosya.oku(yol: metin)`	metin	Dosyanın tüm içeriğini okur
`dosya.yaz(yol: metin, icerik: metin)`	tam	Dosyaya yazar (üzerine yazar), başarıda 0 döndürür
`dosya.ekle(yol: metin, icerik: metin)`	tam	Dosya sonuna ekler
`dosya.satirlar(yol: metin)`	dizi	Dosyayı satır satır okur

Varlık Kontrolleri

Fonksiyon	Dönüş	Açıklama
`dosya.var_mi(yol: metin)`	mantık	Dosya/dizin var mı kontrol eder
`dosya.dizin_mi(yol: metin)`	mantık	Yolun bir dizin olup olmadığını kontrol eder
`dosya.dosya_mi(yol: metin)`	mantık	Yolun bir dosya olup olmadığını kontrol eder
`dosya.okunabilir_mi(yol: metin)`	mantık	Dosya okunabilir mi?
`dosya.yazilabilir_mi(yol: metin)`	mantık	Dosya yazılabilir mi?

Dizin İşlemleri

Fonksiyon	Dönüş	Açıklama
`dosya.klasör_oluştur(yol: metin)`	tam	Tek seviye dizin oluşturur
`dosya.klasör_oluştur_hepsi(yol: metin)`	tam	Tüm ara dizinleri oluşturur (mkdir -p gibi)
`dosya.listele(yol: metin)`	dizi	Dizindeki dosya ve klasörleri listeler
`dosya.alt_dizinler(yol: metin)`	dizi	Sadece alt dizinleri listeler
`dosya.dosyalar(yol: metin)`	dizi	Sadece dosyaları listeler

Silme / Taşıma / Kopyalama

Fonksiyon	Dönüş	Açıklama
`dosya.sil(yol: metin)`	tam	Dosya veya boş dizin siler
`dosya.sil_özyineli(yol: metin)`	tam	Dizini içeriğiyle birlikte siler
`dosya.taşı(kaynak: metin, hedef: metin)`	tam	Dosya/dizin taşır
`dosya.kopyala(kaynak: metin, hedef: metin)`	tam	Dosya kopyalar
`dosya.yeniden_adlandır(eski: metin, yeni: metin)`	tam	Yeniden adlandırır

Meta Veri

Fonksiyon	Dönüş	Açıklama
`dosya.boyut(yol: metin)`	tam	Dosya boyutunu bayt olarak döndürür
`dosya.değiştirilme_zamanı(yol: metin)`	tam	Unix timestamp olarak değiştirilme zamanı
`dosya.oluşturulma_zamanı(yol: metin)`	tam	Unix timestamp olarak oluşturulma zamanı
`dosya.izinler(yol: metin)`	tam	Unix izin bitlerini döndürür (örn: 0644)
`dosya.izin_ayarla(yol: metin, mod: tam)`	tam	Dosya izinlerini ayarlar

Yol İşlemleri

Fonksiyon	Dönüş	Açıklama
`dosya.mutlak_yol(yol: metin)`	metin	Göreceli yolu mutlak yola çevirir
`dosya.üst_dizin(yol: metin)`	metin	Üst dizini döndürür: /a/b/c → /a/b
`dosya.temel_ad(yol: metin)`	metin	Dosya adını döndürür: /a/b/dosya.txt → dosya.txt
`dosya.uzantı(yol: metin)`	metin	Uzantıyı döndürür: dosya.txt → .txt
`dosya.yol_birleştir(yol1: metin, yol2: metin)`	metin	İki yolu birleştirir: /a + b/c → /a/b/c

Glob Desenleri ve Geçici Dosyalar

Fonksiyon	Dönüş	Açıklama
`dosya.glob(desen: metin)`	dizi	.txt, .tr gibi desenleri arar
`dosya.glob_özyineli(desen: metin)`	dizi	Özyinelemeli glob arama
`dosya.geçici_dosya()`	metin	Benzersiz geçici dosya yolu oluşturur
`dosya.geçici_dizin()`	metin	Benzersiz geçici dizin oluşturur

Sembolik Bağlantılar ve Çalışma Dizini

Fonksiyon	Dönüş	Açıklama
`dosya.sembolik_bağ_oluştur(hedef: metin, bağ: metin)`	tam	Sembolik bağlantı oluşturur
`dosya.sembolik_bağ_mı(yol: metin)`	mantık	Sembolik bağlantı mı?
`dosya.sembolik_bağ_oku(yol: metin)`	metin	Bağlantının hedefini döndürür
`dosya.mevcut_dizin()`	metin	Çalışma dizinini döndürür
`dosya.dizin_değiştir(yol: metin)`	tam	Çalışma dizinini değiştirir
`dosya.ev_dizini()`	metin	Kullanıcı ev dizinini döndürür

Örnek: Dosya Okuma ve Yazma

kullan dosya

# Dosyaya yaz
dosya.yaz("notlar.txt", "Merhaba Dünya!")

# Dosyadan oku
metin icerik = dosya.oku("notlar.txt")
yazdır(icerik)  # Merhaba Dünya!

# Dosya var mı kontrol et
eğer dosya.var_mi("notlar.txt") ise
    yazdır("Dosya mevcut, boyutu: ")
    yazdır(dosya.boyut("notlar.txt"))
son

tarih

Tarih ve saat bilgilerine erişim sağlayan modül.

kullan tarih

Fonksiyon	Dönüş	Açıklama
`tarih_şimdi()`	metin	Şu anki tarih/saat: “2026-02-27 13:45:30” formatında
`tarih_gün()`	tam	Gün numarası (1-31)
`tarih_ay()`	tam	Ay numarası (1-12)
`tarih_yıl()`	tam	Yıl (örn: 2026)
`tarih_saat()`	tam	Saat (0-23)
`tarih_dakika()`	tam	Dakika (0-59)
`tarih_saniye()`	tam	Saniye (0-59)
`tarih_damga()`	tam	Unix timestamp (epoch saniye)
`tarih_gün_adı()`	metin	Türkçe gün adı (örn: “Pazartesi”)
`tarih_ay_adı()`	metin	Türkçe ay adı (örn: “Şubat”)

Örnek: Tarih Bilgisi Gösterme

kullan tarih

yazdır(tarih_şimdi())      # 2026-02-27 14:30:00
yazdır(tarih_gün_adı())  # Cuma
yazdır(tarih_ay_adı())   # Şubat
yazdır(tarih_yıl())      # 2026
yazdır(tarih_damga())    # 1772150200 (Unix timestamp)

biçimlendirme

Sayı ve metin biçimlendirme modülü. Sıfır doldurma, para formatı, binlik ayırıcı ve metin hizalama fonksiyonları sağlar.

kullan biçimlendirme

Fonksiyon	Dönüş	Açıklama
`sıfır_doldur(sayı: tam, genişlik: tam)`	metin	Sayıyı belirtilen genişlikte sıfırla doldurur: `sıfır_doldur(42, 5)` → `"00042"`
`ondalık_biçimle(sayı: ondalık, basamak: tam)`	metin	Ondalık sayıyı formatlar: `ondalık_biçimle(3.14159, 2)` → `"3.14"`
`para_biçimle(sayı: ondalık)`	metin	Türkçe para formatı: `para_biçimle(1234567.89)` → `"1.234.567,89"`
`para_biçimle_sembol(sayı: ondalık, sembol: metin)`	metin	Sembol ekleyerek formatlar: `"1.234,56 TL"`
`binlik_ayır(sayı: tam)`	metin	Binlik ayırıcı ekler: `binlik_ayır(1234567)` → `"1.234.567"`
`sağa_hizala(metin: metin, genişlik: tam)`	metin	Metni sağa hizalar (boşlukla doldurur)
`sola_hizala(metin: metin, genişlik: tam)`	metin	Metni sola hizalar (boşlukla doldurur)
`ortala(metin: metin, genişlik: tam)`	metin	Metni ortalar
`ondalık_binlik(sayı: ondalık, basamak: tam)`	metin	Binlik ayırıcılı ondalık: `"1.234,56"`

Örnek: Sayı Biçimlendirme

kullan biçimlendirme

yazdır(sıfır_doldur(42, 5))          # 00042
yazdır(para_biçimle(1234567.89))    # 1.234.567,89
yazdır(binlik_ayır(1000000))       # 1.000.000
yazdır(sağa_hizala("test", 10))    #       test
yazdır(ortala("başlık", 20))       #        başlık

csv

CSV (Comma-Separated Values) dosya okuma, yazma ve ayrıştırma modülü. Dosya tabanlı ve metin tabanlı işlemler desteklenir.

kullan csv

Fonksiyon	Dönüş	Açıklama
`csv_oku(dosya: metin)`	dizi	CSV dosyasını okur, 2 boyutlu dizi döndürür
`csv_ayır(satır: metin)`	dizi	Tek CSV satırını alanlarına ayırır
`csv_ayır_özel(satır: metin, ayırıcı: tam)`	dizi	Özel ayırıcı karakterle ayırır (ASCII kodu)
`csv_satır_oluştur(alanlar: dizi)`	metin	Diziden CSV satırı oluşturur
`csv_yaz(dosya: metin, veri: dizi)`	tam	2 boyutlu diziyi CSV dosyasına yazar
`csv_oku_özel(dosya: metin, ayırıcı: tam)`	dizi	Özel ayırıcıyla CSV okur
`csv_satır_al(veri: dizi, satır: tam)`	dizi	Belirli satırı dizi olarak döndürür
`csv_alan_al(veri: dizi, satır: tam, alan: tam)`	metin	Belirli hücredeki değeri döndürür
`csv_satır_sayısı(veri: dizi)`	tam	Toplam satır sayısı
`csv_alan_sayısı(veri: dizi, satır: tam)`	tam	Belirli satırdaki alan sayısı

Örnek: CSV Dosya İşlemleri

kullan csv

# Tek satır ayrıştırma
dizi alanlar = csv_ayır("Ali,25,İstanbul")
yazdır(alanlar[0])  # Ali
yazdır(alanlar[2])  # İstanbul

# Satır oluşturma
metin satir = csv_satır_oluştur(alanlar)
yazdır(satir)        # Ali,25,İstanbul

sözlük

Anahtar-değer çiftleri saklayan sözlük (hash map) veri yapısı. Anahtarlar metin, değerler tam sayıdır.

kullan sözlük

Fonksiyon	Dönüş	Açıklama
`yeni()`	tam	Yeni boş sözlük oluşturur, tanıtıcı döndürür
`ekle(sözlük: tam, anahtar: metin, değer: tam)`	tam	Anahtar-değer çifti ekler/günceller
`oku(sözlük: tam, anahtar: metin)`	tam	Anahtarın değerini döndürür
`uzunluk(sözlük: tam)`	tam	Sözlükteki öğe sayısı
`var_mı(sözlük: tam, anahtar: metin)`	tam	Anahtar mevcut mu? 1=evet, 0=hayır
`anahtarlar(sözlük: tam)`	dizi	Tüm anahtarları dizi olarak döndürür

Örnek: Sözlük Kullanımı

kullan sözlük

tam puan = yeni()
ekle(puan, "Ali", 95)
ekle(puan, "Veli", 87)
ekle(puan, "Ayşe", 100)

yazdır(oku(puan, "Ali"))      # 95
yazdır(uzunluk(puan))         # 3
yazdır(var_mı(puan, "Veli"))  # 1

Masaüstü GUI (GTK3)

Tonyukuk, GTK3 kütüphanesi üzerine inşa edilmiş tam teşekküllü bir masaüstü GUI sistemi sunar. Pencere yönetimi, 15+ widget çeşidi, callback tabanlı olay sistemi, menü çubuğu, diyalog pencereleri, sistem panosu ve WebView entegrasyonu içerir.

Gereksinimler

# GTK3 geliştirme kütüphaneleri
$ sudo apt install libgtk-3-dev

# WebView modülü için (isteğe bağlı)
$ sudo apt install libwebkit2gtk-4.0-dev

Minimal Örnek

kullan pencere
kullan grafik

baslat()
tam p = olustur("Merhaba", 400, 300)

tam etiket1 = etiket("Merhaba Dünya!")
icerik_ayarla(p, etiket1)
goster(p)

iken kapatildi_mi(p) == 0 ise
    olaylari_isle()
son

Derleme

# GTK modülleri otomatik algılanır
$ ./tonyukuk-derle program.tr -o program
$ ./program

pencere

GTK3 pencere oluşturma, yönetme ve olay döngüsü modülü. Tüm GUI uygulamaları bu modülle başlar.

kullan pencere

Başlatma ve Oluşturma

Fonksiyon	Dönüş	Açıklama
`baslat()`	tam	GTK'yı başlatır. Program başında bir kez çağrılmalı
`olustur(baslik: metin, genislik: tam, yukseklik: tam)`	tam	Yeni pencere oluşturur, pencere ID döndürür

Pencere Özellikleri

Fonksiyon	Dönüş	Açıklama
`baslik_ayarla(pencere_id: tam, baslik: metin)`	tam	Pencere başlığını değiştirir
`boyut_ayarla(pencere_id: tam, genislik: tam, yukseklik: tam)`	tam	Pencere boyutunu değiştirir
`simge_ayarla(pencere_id: tam, dosya_yolu: metin)`	tam	Pencere simgesini ayarlar
`icerik_ayarla(pencere_id: tam, widget_id: tam)`	tam	Pencereye ana içerik widget’ını ekler

Görünürlük ve Kontrol

Fonksiyon	Dönüş	Açıklama
`goster(pencere_id: tam)`	tam	Pencereyi gösterir
`gizle(pencere_id: tam)`	tam	Pencereyi gizler
`kapat(pencere_id: tam)`	tam	Pencereyi kapatır
`tam_ekran(pencere_id: tam)`	tam	Tam ekran moduna geçer
`tam_ekrandan_cik(pencere_id: tam)`	tam	Tam ekrandan çıkar

Olay Döngüsü

Fonksiyon	Dönüş	Açıklama
`olaylari_isle()`	tam	GTK olaylarını işler (bloklamayan). Ana döngüde her adımda çağrılmalı
`calistir()`	tam	GTK ana döngüsünü çalıştırır (bloklayan — tüm pencereler kapanana kadar)
`kapatildi_mi(pencere_id: tam)`	tam	Pencere kapatıldı mı? 1=evet, 0=hayır

grafik

GTK3 widget kütüphanesi. Düğme, etiket, giriş alanı, metin alanı, sekmeler, onay kutusu, açılır liste, kaydırıcı, ızgara, araç çubuğu, liste görünümü ve daha fazlasını içerir. kullan grafik ile yüklenir.

kullan grafik

Konteynerler ve Yerleşim

Fonksiyon	Dönüş	Açıklama
`kutu_yatay()`	tam	Yatay kutu konteyneri (GtkBox)
`kutu_dikey()`	tam	Dikey kutu konteyneri (GtkBox)
`kaydirma()`	tam	Kaydırma penceresi (GtkScrolledWindow)
`ekle(konteyner_id: tam, widget_id: tam)`	tam	Widget’ı konteynere ekler
`pakle(kutu_id: tam, widget_id: tam, genisle: tam, doldur: tam, bosluk: tam)`	tam	Widget’ı kutuya paketler (genişle/doldur/boşluk)
`goster_tumu(widget_id: tam)`	tam	Widget ve tüm çocuklarını gösterir

Temel Widget’lar

Fonksiyon	Dönüş	Açıklama
`dugme(etiket: metin)`	tam	Düğme oluşturur
`etiket(metin: metin)`	tam	Etiket oluşturur
`giris()`	tam	Tek satırlı metin girişi
`ayirici()`	tam	Görsel ayırıcı çizgi
`resim_dosyadan(yol: metin)`	tam	Dosyadan resim yükler

Giriş Alanı İşlemleri

Fonksiyon	Dönüş	Açıklama
`giris_metni_al(giris_id: tam)`	metin	Giriş alanındaki metni döndürür
`giris_metni_ayarla(giris_id: tam, metin: metin)`	tam	Giriş alanı metnini ayarlar
`giris_ipucu_ayarla(giris_id: tam, ipucu: metin)`	tam	Placeholder metin ayarlar

Etiket İşlemleri

Fonksiyon	Dönüş	Açıklama
`etiket_metni_ayarla(etiket_id: tam, metin: metin)`	tam	Etiket metnini değiştirir
`etiket_metni_al(etiket_id: tam)`	metin	Etiket metnini döndürür

Düğme İşlemleri

Fonksiyon	Dönüş	Açıklama
`dugme_etiket_ayarla(dugme_id: tam, metin: metin)`	tam	Düğme etiketini değiştirir
`dugme_basildi_mi(dugme_id: tam)`	tam	Düğmeye basıldı mı? (yoklama modu)

Metin Alanı (Çok Satırlı)

Fonksiyon	Dönüş	Açıklama
`metin_alani()`	tam	Çok satırlı metin alanı (GtkTextView)
`metin_alani_icerik_al(id: tam)`	metin	Metin alanı içeriğini döndürür
`metin_alani_icerik_ayarla(id: tam, metin: metin)`	tam	Metin alanı içeriğini ayarlar
`metin_alani_salt_oku(id: tam, deger: tam)`	tam	Salt okunur ayarı (1=evet, 0=hayır)

Sekme Yönetimi (GtkNotebook)

Fonksiyon	Dönüş	Açıklama
`sekmeler()`	tam	Sekme paneli oluşturur
`sekme_ekle(notebook_id: tam, icerik_id: tam, baslik: metin)`	tam	Yeni sekme ekler
`sekme_kapatmali_ekle(notebook_id: tam, icerik_id: tam, baslik: metin)`	tam	Kapatılabilir sekme ekler
`sekme_kaldir(notebook_id: tam, indeks: tam)`	tam	Sekmeyi kaldırır
`sekme_secili(notebook_id: tam)`	tam	Seçili sekme indeksi
`sekme_sec(notebook_id: tam, indeks: tam)`	tam	Sekme seçer
`sekme_baslik_ayarla(notebook_id: tam, indeks: tam, baslik: metin)`	tam	Sekme başlığını değiştirir
`sekme_sayisi(notebook_id: tam)`	tam	Toplam sekme sayısı
`sekme_kapandi_mi(notebook_id: tam)`	tam	Kapatılan sekme indeksi veya -1
`sekme_degisti_mi(notebook_id: tam)`	tam	Sekme değişti mi? (yoklama)

Onay Kutusu (GtkCheckButton)

Fonksiyon	Dönüş	Açıklama
`onay_kutusu(etiket: metin)`	tam	Onay kutusu oluşturur
`onay_durumu(id: tam)`	tam	Durum: 0=kapalı, 1=açık
`onay_ayarla(id: tam, deger: tam)`	tam	Onay durumunu ayarlar

Seçim Düğmesi (GtkRadioButton)

Fonksiyon	Dönüş	Açıklama
`secim_dugmesi(grup_id: tam, etiket: metin)`	tam	Radyo düğmesi (-1=yeni grup, ≥0=mevcut gruba ekle)
`secim_durumu(id: tam)`	tam	Seçili mi? 0=hayır, 1=evet

Açılır Liste (GtkComboBox)

Fonksiyon	Dönüş	Açıklama
`acilir_liste()`	tam	Açılır liste oluşturur
`acilir_ekle(id: tam, metin: metin)`	tam	Öğe ekler
`acilir_secili(id: tam)`	tam	Seçili öğe indeksi (-1=seçili değil)
`acilir_sec(id: tam, indeks: tam)`	tam	Öğe seçer
`acilir_metni_al(id: tam)`	metin	Seçili öğenin metnini döndürür

Kaydırıcı (GtkScale)

Fonksiyon	Dönüş	Açıklama
`kaydirici(min: tam, maks: tam)`	tam	Kaydırıcı oluşturur
`kaydirici_degeri(id: tam)`	tam	Geçerli değeri döndürür
`kaydirici_ayarla(id: tam, deger: tam)`	tam	Değeri ayarlar

Sayı Girişi (GtkSpinButton)

Fonksiyon	Dönüş	Açıklama
`sayi_girisi(min: tam, maks: tam)`	tam	Sayı girişi oluşturur
`sayi_degeri(id: tam)`	tam	Geçerli değeri döndürür
`sayi_ayarla(id: tam, deger: tam)`	tam	Değeri ayarlar

İlerleme Çubuğu

Fonksiyon	Dönüş	Açıklama
`ilerleme_cubugu()`	tam	İlerleme çubuğu oluşturur
`ilerleme_ayarla(id: tam, deger: tam)`	tam	İlerleme yüzdesi (0-100)

Izgara (GtkGrid)

Fonksiyon	Dönüş	Açıklama
`izgara(satir: tam, sutun: tam)`	tam	Izgara konteyneri oluşturur
`izgara_ekle(izgara_id: tam, widget_id: tam, satir: tam, sutun: tam)`	tam	Widget’ı hücreye ekler
`izgara_ekle_genislikli(izgara_id: tam, widget_id: tam, satir: tam, sutun: tam, genislik: tam, yukseklik: tam)`	tam	Birden fazla hücreyi kaplayan widget ekler
`izgara_satir_bosluk(izgara_id: tam, bosluk: tam)`	tam	Satır arasındaki boşluk (piksel)
`izgara_sutun_bosluk(izgara_id: tam, bosluk: tam)`	tam	Sütun arasındaki boşluk (piksel)

Araç Çubuğu (GtkToolbar)

Fonksiyon	Dönüş	Açıklama
`arac_cubugu()`	tam	Araç çubuğu oluşturur
`arac_dugme_ekle(cubuk_id: tam, etiket: metin)`	tam	Araç düğmesi ekler, ID döndürür
`arac_ayirici_ekle(cubuk_id: tam)`	tam	Ayırıcı ekler
`arac_dugme_basildi_mi(dugme_id: tam)`	tam	Düğmeye basıldı mı? (yoklama)

Liste Görünümü (GtkListBox)

Fonksiyon	Dönüş	Açıklama
`liste_gorunumu()`	tam	Liste görünümü oluşturur
`liste_oge_ekle(liste_id: tam, metin: metin)`	tam	Öğe ekler
`liste_secili(liste_id: tam)`	tam	Seçili öğe indeksi (-1=seçim yok)
`liste_oge_kaldir(liste_id: tam, indeks: tam)`	tam	Öğeyi kaldırır
`liste_temizle(liste_id: tam)`	tam	Tüm öğeleri temizler
`liste_oge_sayisi(liste_id: tam)`	tam	Öğe sayısını döndürür

CSS Tema ve Widget Özellikleri

Fonksiyon	Dönüş	Açıklama
`css_yukle(css: metin)`	tam	CSS metnini uygulamaya yükler
`css_sinif_ekle(widget_id: tam, sinif: metin)`	tam	Widget’a CSS sınıfı ekler
`css_sinif_kaldir(widget_id: tam, sinif: metin)`	tam	CSS sınıfını kaldırır
`widget_genislik_ayarla(widget_id: tam, genislik: tam)`	tam	Widget genişliğini ayarlar
`widget_yukseklik_ayarla(widget_id: tam, yukseklik: tam)`	tam	Widget yüksekliğini ayarlar
`widget_gizle(widget_id: tam)`	tam	Widget’ı gizler
`widget_goster(widget_id: tam)`	tam	Widget’ı gösterir
`ipucu_ayarla(widget_id: tam, metin: metin)`	tam	Tooltip ayarlar
`giris_enter_mi(giris_id: tam)`	tam	Giriş alanında Enter basıldı mı?

Örnek: Form Kontrolleri

kullan pencere
kullan grafik

baslat()
tam p = olustur("Form Örneği", 400, 300)

tam kutu = kutu_dikey()
tam g = giris()
giris_ipucu_ayarla(g, "Adınızı girin...")

tam onay = onay_kutusu("Kabul ediyorum")
tam kaydir = kaydirici(0, 100)
tam btn = dugme("Gönder")

pakle(kutu, g, 0, 0, 5)
pakle(kutu, onay, 0, 0, 5)
pakle(kutu, kaydir, 0, 0, 5)
pakle(kutu, btn, 0, 0, 5)

icerik_ayarla(p, kutu)
goster(p)

iken kapatildi_mi(p) == 0 ise
    olaylari_isle()
    eğer dugme_basildi_mi(btn) == 1 ise
        yazdır(giris_metni_al(g))
    son
son

olay

Callback tabanlı olay sistemi. Yoklama (polling) yerine widget olaylarına fonksiyon bağlayarak olaya dayalı programlama yapmanızı sağlar.

kullan olay

Olay Dinleme

Fonksiyon	Dönüş	Açıklama
`olay_dinle(widget_id: tam, olay_adi: metin, fonksiyon: işlev)`	tam	Widget’a olay dinleyici bağlar. Kayıt ID döndürür
`olay_kaldir(kayit_id: tam)`	tam	Olay kaydını devre dışı bırakır

Desteklenen olaylar: "tikla", "degisti", "enter", "sekme_degisti", "kapatildi", "deger_degisti", "tus_basildi", "fare_tiklandi"

Olay İşleme

Fonksiyon	Dönüş	Açıklama
`olaylari_isle_ve_cagir()`	tam	Bekleyen callback kuyruğunu boşaltır, her birini çağırır. İşlenen olay sayısını döndürür
`olay_sayisi()`	tam	Kuyrukta bekleyen olay sayısı

Klavye ve Fare Sorguları

Fonksiyon	Dönüş	Açıklama
`son_tus_kodu()`	tam	Son basılan tuşun kodu (GDK keyval)
`son_fare_x()`	tam	Son fare olayının X koordinatı
`son_fare_y()`	tam	Son fare olayının Y koordinatı
`son_fare_dugme()`	tam	Son fare düğmesi (1=sol, 2=orta, 3=sağ)

Örnek: Callback Tabanlı Olaylar

kullan pencere
kullan grafik
kullan olay

işlev tikla_cb(widget_id: tam) -> tam
    yazdır("Düğmeye tıklandı!")
    döndür 0
son

baslat()
tam p = olustur("Olay Testi", 300, 200)
tam btn = dugme("Tıkla!")
olay_dinle(btn, "tikla", tikla_cb)

icerik_ayarla(p, btn)
goster(p)

iken kapatildi_mi(p) == 0 ise
    olaylari_isle()
    olaylari_isle_ve_cagir()
son

Menü çubuğu, alt menüler ve menü öğeleri modülü. Standart uygulama menüleri oluşturmanızı sağlar.

kullan menu

Fonksiyon	Dönüş	Açıklama
`menu_cubugu()`	tam	Menü çubuğu oluşturur
`menu_pencereye_ekle(pencere_id: tam, cubuk_id: tam)`	tam	Menü çubuğunu pencereye ekler
`menu_olustur(etiket: metin)`	tam	Alt menü oluşturur (örn: “Dosya”)
`menu_cubuga_ekle(cubuk_id: tam, menu_id: tam)`	tam	Alt menüyü çubuğa ekler
`menu_oge_ekle(menu_id: tam, etiket: metin)`	tam	Menü öğesi ekler, ID döndürür
`menu_ayirici_ekle(menu_id: tam)`	tam	Menüye ayırıcı ekler
`menu_onay_oge_ekle(menu_id: tam, etiket: metin)`	tam	Onay kutulu menü öğesi
`menu_oge_secildi_mi(oge_id: tam)`	tam	Menü öğesi seçildi mi? (yoklama)
`menu_onay_durumu(oge_id: tam)`	tam	Onay kutulu öğe durumu (0/1)

Örnek: Menü Çubuğu

kullan pencere
kullan grafik
kullan menu

baslat()
tam p = olustur("Menü Örneği", 500, 400)

tam mc = menu_cubugu()

# Dosya menüsü
tam dosya_m = menu_olustur("Dosya")
tam m_yeni = menu_oge_ekle(dosya_m, "Yeni")
tam m_ac = menu_oge_ekle(dosya_m, "Aç...")
menu_ayirici_ekle(dosya_m)
tam m_cik = menu_oge_ekle(dosya_m, "Çıkış")
menu_cubuga_ekle(mc, dosya_m)

menu_pencereye_ekle(p, mc)

diyalog

Mesaj kutuları, dosya aç/kaydet diyalogları ve renk seçici diyalog penceresi modülü.

kullan diyalog

Fonksiyon	Dönüş	Açıklama
`mesaj_kutusu(baslik: metin, mesaj: metin, tip: tam)`	tam	Mesaj kutusu gösterir. tip: 0=bilgi, 1=uyarı, 2=hata, 3=soru. Dönüş: 1=Tamam/Evet, 0=İptal/Hayır
`dosya_ac(baslik: metin, filtre: metin)`	metin	Dosya açma diyaloğu. Filtre: `"Metin (.txt)\|Tümü ()"`. Seçilen yol veya `""` döndürür
`dosya_kaydet(baslik: metin, filtre: metin)`	metin	Dosya kaydetme diyaloğu
`renk_sec(baslik: metin)`	tam	Renk seçici. RGB değeri (0xRRGGBB) veya -1 (iptal) döndürür

Örnek: Diyalog Pencereleri

kullan pencere
kullan diyalog

# Bilgi mesajı
mesaj_kutusu("Bilgi", "İşlem tamamlandı!", 0)

# Soru sor
tam cevap = mesaj_kutusu("Onay", "Devam etmek istiyor musunuz?", 3)

# Dosya aç
metin yol = dosya_ac("Dosya Aç", "Tonyukuk (*.tr)|Metin (*.txt)|Tümü (*)")

# Renk seç
tam renk = renk_sec("Renk Seçin")

pano

Sistem panosuna (clipboard) metin kopyalama ve yapıştırma modülü.

kullan pano

Fonksiyon	Dönüş	Açıklama
`pano_yaz(metin: metin)`	tam	Panoya metin yazar (kopyala)
`pano_oku()`	metin	Panodan metin okur (yapıştır)
`pano_boş_mu()`	tam	Panoda metin var mı? 1=boş, 0=dolu
`pano_temizle()`	tam	Pano içeriğini temizler

Örnek: Pano Kullanımı

kullan pano

pano_yaz("Kopyalanan metin")
metin icerik = pano_oku()
yazdır(icerik)  # Kopyalanan metin

eğer pano_boş_mu() == 0 ise
    yazdır("Panoda veri var")
son

web

WebKit2GTK tabanlı web görünümü (WebView) modülü. Tarayıcı gömülmesi, JavaScript çalıştırma ve JS↔Tonyukuk mesaj köprüsü sağlar. libwebkit2gtk-4.0-dev gerektirir.

kullan web

Oluşturma ve Gezinti

Fonksiyon	Dönüş	Açıklama
`wg_olustur()`	tam	Web görünümü widget’ı oluşturur
`wg_yukle(wv_id: tam, url: metin)`	tam	URL yükler
`wg_html_yukle(wv_id: tam, html: metin)`	tam	HTML içerike doğrudan yükler
`wg_geri(wv_id: tam)`	tam	Geri gider
`wg_ileri(wv_id: tam)`	tam	İleri gider
`wg_yenile(wv_id: tam)`	tam	Sayfayı yeniler
`wg_durdur(wv_id: tam)`	tam	Yüklemeyi durdurur

Bilgi Sorgulama ve Durum

Fonksiyon	Dönüş	Açıklama
`wg_baslik_al(wv_id: tam)`	metin	Sayfa başlığını döndürür
`wg_adres_al(wv_id: tam)`	metin	Geçerli URL’yi döndürür
`wg_geri_gidebilir_mi(wv_id: tam)`	tam	Geçmişte geri gidilebilir mi?
`wg_ileri_gidebilir_mi(wv_id: tam)`	tam	Geçmişte ileri gidilebilir mi?
`wg_yukleniyor_mu(wv_id: tam)`	tam	Sayfa yükleniyor mu?
`wg_yuklenme_yuzdesi(wv_id: tam)`	tam	Yüklenme yüzdesi (0-100)
`wg_widget_id(wv_id: tam)`	tam	Arayüz widget kimliği (yerleşim için)

Olay Yoklama

Fonksiyon	Dönüş	Açıklama
`wg_baslik_degisti_mi(wv_id: tam)`	tam	Başlık değişti mi?
`wg_adres_degisti_mi(wv_id: tam)`	tam	Adres değişti mi?
`wg_yuklenme_bitti_mi(wv_id: tam)`	tam	Yüklenme tamamlandı mı?

Yakınlaştırma

Fonksiyon	Dönüş	Açıklama
`wg_yakinlastir(wv_id: tam)`	tam	Yakınlaştırır
`wg_uzaklastir(wv_id: tam)`	tam	Uzaklaştırır
`wg_yakinlik_sifirla(wv_id: tam)`	tam	Yakınlaştırmayı sıfırlar

JavaScript ve Köprü

Fonksiyon	Dönüş	Açıklama
`wg_js_calistir(wv_id: tam, kod: metin)`	tam	JavaScript kodu çalıştırır
`wg_kopru_kur(wv_id: tam)`	tam	JS↔Tonyukuk mesaj köprüsünü başlatır
`wg_mesaj_gonder(wv_id: tam, mesaj: metin)`	tam	Tonyukuk→JS mesaj gönderir
`wg_mesaj_al(wv_id: tam)`	metin	JS→Tonyukuk mesaj alır (kuyruktan)
`wg_mesaj_var_mi(wv_id: tam)`	tam	Bekleyen mesaj var mı?

Örnek: Basit Tarayıcı

kullan pencere
kullan grafik
kullan web

baslat()
tam p = olustur("Tarayıcı", 800, 600)

tam wv = wg_olustur()
wg_yukle(wv, "https://tonyukuktr.com")

tam wid = wg_widget_id(wv)
icerik_ayarla(p, wid)
goster(p)

iken kapatildi_mi(p) == 0 ise
    olaylari_isle()
    eğer wg_baslik_degisti_mi(wv) == 1 ise
        baslik_ayarla(p, wg_baslik_al(wv))
    son
son

Örnek: JS↔Tonyukuk Köprüsü

kullan pencere
kullan grafik
kullan web

baslat()
tam p = olustur("Köprü", 600, 400)
tam wv = wg_olustur()
wg_kopru_kur(wv)

metin html = "<button onclick='tonyukuk.gonder(\"merhaba\")'>Gönder</button>"
wg_html_yukle(wv, html)

tam wid = wg_widget_id(wv)
icerik_ayarla(p, wid)
goster(p)

iken kapatildi_mi(p) == 0 ise
    olaylari_isle()
    eğer wg_mesaj_var_mi(wv) == 1 ise
        metin msj = wg_mesaj_al(wv)
        yazdır(msj)  # JS'den gelen mesaj
        wg_mesaj_gonder(wv, "selam JS!")
    son
son

Biçimleyici (bicimle)

Tonyukuk biçimleyicisi, kaynak kodunuzu tutarlı bir stile otomatik olarak düzenler. Girinti, boşluklar ve satır sonları standart formata getirilir.

Kullanım

# Dosyayı biçimle ve sonucu göster
$ bicimle dosya.tr

# Dosyayı yerinde biçimle (üzerine yaz)
$ bicimle -y dosya.tr

# Dizindeki tüm .tr dosyalarını biçimle
$ bicimle -y *.tr

Seçenekler

Seçenek	Açıklama
`-y`	Dosyayı yerinde düzenle (üzerine yaz)
`-g`	Girinti boyutu (varsayılan: 4 boşluk)
`-t`	Tab karakteri kullan (boşluk yerine)
`--kontrol`	Sadece kontrol et, değişiklik yapma (CI için)

Biçimleme Kuralları

Girintileme: 4 boşluk (varsayılan)
Operatörler etrafında boşluk: a + b, x == y
Fonksiyon çağrısı sonrası boşluk yok: yazdır(x)
Blok anahtar kelimeleri aynı girintide: eğer/yoksa/son
Dosya sonunda boş satır

Denetleyici (denetle)

Tonyukuk denetleyicisi (linter), kodunuzda olası hataları, kötü alışkanlıkları ve performans sorunlarını tespit eder.

Kullanım

# Dosyayı denetle
$ denetle dosya.tr

# Dizindeki tüm dosyaları denetle
$ denetle *.tr

# Belirli kuralları devre dışı bırak
$ denetle --kural-kapat=kullanilmayan dosya.tr

Kontrol Edilen Kurallar

Kural	Açıklama
`kullanilmayan`	Kullanılmayan değişkenler ve fonksiyonlar
`golgeleme`	Dış kapsamdaki değişkeni gölgeleyen tanımlamalar
`tip_uyusmazligi`	Tip uyumsuzluğu uyarıları
`sonsuz_dongu`	Olası sonsuz döngü tespiti
`bos_blok`	Boş eğer/döngü/fonksiyon blokları
`isimlendirme`	İsimlendirme kuralları (yılan_durum önerisi)
`karmasiklik`	Yüksek siklomatik karmaşıklık uyarısı

Paket Yöneticisi (ton)

ton, Tonyukuk projelerini oluşturmak, bağımlılıkları yönetmek ve paketleri paylaşmak için kullanılan paket yöneticisidir.

Temel Komutlar

# Yeni proje oluştur
$ ton yeni projem
$ cd projem

# Mevcut dizinde proje başlat
$ ton baslat

# Bağımlılıkları yükle
$ ton yukle

# Projeyi derle
$ ton derle

# Projeyi çalıştır
$ ton calistir

# Testleri çalıştır
$ ton test

Proje Yapısı

ton yeni projem komutu aşağıdaki yapıyı oluşturur:

projem/
├── ton.toml          # Proje yapılandırması
├── kaynak/
│   └── ana.tr        # Ana kaynak dosyası
├── test/
│   └── test_ana.tr   # Test dosyası
└── .gitignore

ton.toml Dosya Formatı

[proje]
ad = "projem"
surum = "0.1.0"
yazar = "Ad Soyad"
aciklama = "Proje açıklaması"

[bagimliliklar]
json_isle = "1.2.0"
ag_yardimci = "0.5.0"

[derleme]
backend = "llvm"
optimizasyon = "O2"
hedef = "x86_64"

Komut Referansı

Komut	Açıklama
`ton yeni <ad>`	Yeni proje iskelesi oluştur
`ton baslat`	Mevcut dizinde proje başlat
`ton yukle`	Bağımlılıkları indir ve yükle
`ton derle`	Projeyi derle
`ton calistir`	Projeyi derle ve çalıştır
`ton test`	Testleri çalıştır
`ton yayinla`	Paketi kayıt defterine yayınla

LSP Sunucu (tonyukuk-lsp)

Tonyukuk LSP (Language Server Protocol) sunucusu, kod düzenleyicilere akıllı özellikler sağlar.

VS Code Entegrasyonu

Tonyukuk VS Code eklentisi LSP sunucusunu otomatik olarak başlatır. Manuel kurulum için:

# LSP sunucusunu kur
$ sudo make install-lsp

# VS Code ayarlarına ekle (settings.json)
{
    "tonyukuk.lsp.yol": "/usr/local/bin/tonyukuk-lsp",
    "tonyukuk.lsp.etkin": true
}

Desteklenen Özellikler

Özellik	Açıklama
Sözdizimi Renklendirme	Anahtar kelimeler, tipler, fonksiyonlar, metinler ve yorumlar renklendirmesi
Otomatik Tamamlama	Değişken, fonksiyon ve modül isimleri önerileri
Anlık Hata Tespiti	Sözdizimi ve tip hataları yazarken gösterilir
Tanıma Git	Fonksiyon veya değişken tanımına atlama (F12)
Fare ile Bilgi	İmleç üzerine gelindiğinde tip ve belge bilgisi
Sembol Arama	Projedeki tüm sembolleri arayabilme (Ctrl+T)
Biçimleme	Belge biçimleme desteği (Shift+Alt+F)

Hata Ayıklayıcı (tonyukuk-ha)

tonyukuk-ha, Tonyukuk programlarını adım adım çalıştırmanıza, değişkenleri incelemenize ve kesme noktaları koymanıza olanak tanıyan Türkçe hata ayıklayıcıdır.

Başlangıç

# Debug bilgisi ile derle
$ tonyukuk-derle --backend=llvm -g program.tr -o program

# Hata ayıklayıcıyı başlat
$ tonyukuk-ha ./program

Komutlar

Komut	Kısaltma	Açıklama
`kes <satır>`	`k`	Belirtilen satıra kesme noktası koy
`kes <fonksiyon>`	`k`	Fonksiyon başına kesme noktası koy
`devam`	`d`	Bir sonraki kesme noktasına kadar çalıştır
`adım`	`a`	Bir satır ilerle (fonksiyonun içine gir)
`atla`	`at`	Bir satır ilerle (fonksiyonun içine girme)
`göster <değişken>`	`g`	Değişkenin değerini göster
`göster *`	`g *`	Tüm yerel değişkenleri göster
`yığın`	`y`	Çağrı yığınını (backtrace) göster
`listele`	`l`	Şu anki konumdaki kaynak kodu göster
`sil <numara>`	`s`	Kesme noktasını kaldır
`çık`	`c`	Hata ayıklayıcıdan çık

Örnek Oturum

$ tonyukuk-ha ./program
Tonyukuk Hata Ayıklayıcı v1.0
Kaynak: program.tr (12 satır)

(ha) kes 5
Kesme noktası #1: satır 5

(ha) devam
Kesme noktası #1, satır 5: tam sonuc = topla(a, b)

(ha) göster a
a = 10 (tam)

(ha) göster b
b = 20 (tam)

(ha) adım
satır 2: döndür a + b

(ha) göster *
a = 10 (tam)
b = 20 (tam)

(ha) devam
Sonuç: 30
Program tamamlandı.

(ha) çık

Generator (Üreteç)

üreteç işlev sayilar() -> tam
    üret 1
    üret 2
    üret 3
son

Desen Eşleme

eşle ifadesi ile değer-bazlı desen eşleme yapılır:

eşle komut ise
    durum "ekle":
        yazdır("Eklendi")
    durum "sil":
        yazdır("Silindi")
    varsayılan:
        yazdır("Bilinmeyen komut")
son

Pipe Operatörü

# |> ile fonksiyon zincirleme
sonuc = deger |> fonk1 |> fonk2

Test Çerçevesi

test "toplama testi"
    doğrula(2 + 2 == 4)
    doğrula(3 * 3 == 9)
son

Test sonrasında otomatik rapor üretilir: başarılı/başarısız test sayıları görüntülenir.

Derleme Seçenekleri

Tonyukuk derleyicisi çeşitli seçenekler sunar:

$ tonyukuk-derle [seçenekler] <kaynak.tr>

Seçenek	Açıklama
`-o <dosya>`	Çıktı dosya adı
`-s`	Assembly dosyasını sakla
`-g`	Hata ayıklama bilgisi ekle (DWARF)
`-hedef <tür>`	Hedef platform: x86_64, arm64, wasm, windows
`-O`	Optimizasyon (sabit katlama, ölü kod eleme)
`-O0/-O1/-O2/-O3`	LLVM optimizasyon seviyesi
`--backend=llvm`	LLVM IR backend kullan
`--emit-llvm`	LLVM IR dosyası (.ll) üret
`--emit-bc`	LLVM bitcode dosyası (.bc) üret
`--emit-asm`	Assembly dosyası (.s) üret
`--emit-obj`	Nesne dosyası (.o) üret
`--verify-ir`	IR doğrulamasını etkinleştir
`--jit`	JIT modunda çalıştır (derleme yapmadan)
`--sına`	Test modunda derle
`--etkileşimli`	Etkileşimli REPL modunu başlat

Örnekler

# Temel derleme
$ tonyukuk-derle merhaba.tr -o merhaba

# LLVM backend ile O2 optimizasyonu
$ tonyukuk-derle --backend=llvm -O2 merhaba.tr

# Debug bilgisi ile derleme
$ tonyukuk-derle --backend=llvm -g merhaba.tr -o debug_test

# LLVM IR dosyası üret
$ tonyukuk-derle --backend=llvm --emit-llvm merhaba.tr

# JIT ile direkt çalıştır
$ tonyukuk-derle --backend=llvm --jit merhaba.tr

# WebAssembly hedefi
$ tonyukuk-derle --backend=llvm -hedef wasm merhaba.tr -o merhaba.wasm

LLVM Backend

Tonyukuk, LLVM 17 altyapısını kullanarak çoklu platform desteği, gelişmiş optimizasyonlar, JIT derleme ve WebAssembly üretimi sunar. LLVM backend, kaynak kodu önce LLVM IR'e (Intermediate Representation) dönüştürür, ardından hedef platforma uygun makine kodu üretir.

Çoklu Platform Desteği

LLVM backend, tek kaynak koddan birden fazla hedef platform için derleme yapabilir. -hedef parametresi ile hedef seçilir:

Platform	Target Triple	Komut	Açıklama
Linux x86_64	`x86_64-pc-linux-gnu`	`--backend=llvm`	Varsayılan hedef
Linux ARM64	`aarch64-unknown-linux-gnu`	`--backend=llvm -hedef arm64`	ARM64 işlemciler (Raspberry Pi, M1 vb.)
WebAssembly	`wasm32-unknown-unknown`	`--backend=llvm -hedef wasm`	Tarayıcı ve WASM runtime'lar
Windows	`x86_64-pc-windows-msvc`	`--backend=llvm -hedef windows`	Windows (cross-compile)

# x86_64 (varsayılan)
$ tonyukuk-derle --backend=llvm program.tr -o program

# ARM64 cross-compile
$ tonyukuk-derle --backend=llvm -hedef arm64 program.tr -o program_arm

# WebAssembly binary
$ tonyukuk-derle --backend=llvm -hedef wasm program.tr -o program.wasm

Optimizasyon Seviyeleri

LLVM, kaynak kodunuzu analiz ederek otomatik optimizasyon uygular. Farklı seviyelerde performans/derleme süresi dengesini ayarlayabilirsiniz:

Seviye	Açıklama	Kullanım Alanı
`-O0`	Optimizasyon yok — hızlı derleme	Geliştirme, debug
`-O1`	Temel optimizasyonlar (sabit katlama, basit inline)	Geliştirme, hızlı testler
`-O2`	Önerilen: sabit katlama, ölü kod eleme, fonksiyon inline, döngü optimizasyonu	Üretim, genel kullanım
`-O3`	Agresif: loop unrolling, vektörizasyon, tail call optimizasyonu	Hesaplama yoğun uygulamalar

# Optimizasyonsuz derleme (debug için)
$ tonyukuk-derle --backend=llvm program.tr

# O2 optimizasyonu ile (önerilen)
$ tonyukuk-derle --backend=llvm -O2 program.tr -o program

# Agresif optimizasyon
$ tonyukuk-derle --backend=llvm -O3 program.tr -o program

Öneri: Üretim için -O2 kullanın. -O3 bazen kod boyutunu artırabilir ve beklenmeyen davranışlara yol açabilir. -O0 ise debug bilgisi ile birlikte (-g) en iyi sonuçları verir.

JIT Derleme

LLVM JIT (Just-In-Time) ile kodu dosya oluşturmadan bellekte derleyip doğrudan çalıştırabilirsiniz. Bu mod, herhangi bir çıktı dosyası oluşturmaz — kod anında çalışır ve sonuç terminale yazılır:

# JIT ile anında çalıştır
$ tonyukuk-derle --backend=llvm --jit program.tr

# JIT + optimizasyon birlikte kullanılabilir
$ tonyukuk-derle --backend=llvm --jit -O2 program.tr

JIT modunun kullanım alanları:

Hızlı prototipleme: Kodu derlemeden doğrudan test edin
Script benzeri kullanım: Derleme adımı olmadan çalıştırma
REPL benzeri deneyim: Kod yaz, anında sonuç gör

IR Üretimi ve İnceleme

LLVM IR (Intermediate Representation), kaynak kodunuzun derlenmiş ancak henüz makine koduna dönüştürülmemiş halidir. IR dosyasını incelemek, derleyicinin kodunuzu nasıl anladığını görmenizi sağlar:

# IR dosyası üret
$ tonyukuk-derle --backend=llvm --emit-llvm program.tr -o program.ll
$ cat program.ll

# IR + optimizasyon birlikte: optimizasyonların etkisini görün
$ tonyukuk-derle --backend=llvm --emit-llvm -O2 program.tr -o program_opt.ll

Örnek: Basit bir toplama fonksiyonu:

# Tonyukuk kaynak kodu
işlev topla(a: tam, b: tam) -> tam
    döndür a + b
son

Üretilen LLVM IR:

; ModuleID = 'tonyukuk_modul'

define i64 @topla(i64 %a, i64 %b) {
giris:
  %toplam = add i64 %a, %b
  ret i64 %toplam
}

Örnek: Fibonacci fonksiyonu (O2 optimizasyonu ile tail call uygulanmış):

# Tonyukuk kaynak kodu
işlev fib(n: tam) -> tam
    eğer n <= 1 ise
        döndür n
    son
    döndür fib(n - 1) + fib(n - 2)
son

Oluşan IR'de rekürsif çağrılar, koşullu dallanmalar ve tamsayı aritmetiği görülebilir:

define i64 @fib(i64 %n) {
giris:
  %kosul = icmp sle i64 %n, 1
  br i1 %kosul, label %temel, label %rekursif

temel:
  ret i64 %n

rekursif:
  %n1 = sub i64 %n, 1
  %fib1 = call i64 @fib(i64 %n1)
  %n2 = sub i64 %n, 2
  %fib2 = call i64 @fib(i64 %n2)
  %sonuc = add i64 %fib1, %fib2
  ret i64 %sonuc
}

Playground'da IR: Çevrimiçi playground'da backend olarak “LLVM” seçip “IR Göster” kutusunu işaretleyerek kodunuzun LLVM IR çıktısını doğrudan tarayıcıda görebilirsiniz.

Döngü ve Kontrol Akışı (LLVM)

LLVM backend, Tonyukuk'un tüm döngü yapılarını destekler: döngü (sayma), iken (koşullu) ve her...için (foreach). Döngüler LLVM IR'de dört temel blok (basic block) olarak üretilir:

Blok	LLVM Adı	Görevi
Koşul	`dongu_kosul`	Sayaç ≤ bitiş mi kontrol et
Gövde	`dongu_govde`	Döngü içindeki kodları çalıştır
Artırma	`dongu_artir`	Sayacı 1 artır, koşula geri dön
Son	`dongu_son`	Döngü bittiğinde devam noktası

Örnek: 1'den 5'e kadar sayıları yazdırma:

döngü i = 1, 5 ise
    yazdır(i)
son

Bu kodun LLVM IR karşılığı (sadeleştirilmiş):

define i64 @main() {
giris:
  %i = alloca i64
  store i64 1, ptr %i          ; i = 1
  br label %dongu_kosul

dongu_kosul:
  %val = load i64, ptr %i
  %cmp = icmp sle i64 %val, 5   ; i <= 5 ?
  br i1 %cmp, label %dongu_govde, label %dongu_son

dongu_govde:
  call void @_yazdir_tam(i64 %val)
  br label %dongu_artir

dongu_artir:
  %yeni = add i64 %val, 1        ; i += 1
  store i64 %yeni, ptr %i
  br label %dongu_kosul

dongu_son:
  ret i64 0
}

kır anahtar kelimesi dongu_son bloğuna, devam ise dongu_artir bloğuna dallanır. Bu mekanizma iç içe döngülerde de doğru çalışır — her döngü kendi çıkış ve devam bloklarını tutar.

Optimizasyon: -O2 seviyesinde LLVM, döngülere otomatik olarak loop-invariant code motion (döngü dışına taşıma), strength reduction (güç azaltma) ve loop unrolling (döngü açma) optimizasyonlarını uygulayabilir.

WebAssembly

Tonyukuk, LLVM backend üzerinden kodunuzu WebAssembly'e (WASM) derleyerek doğrudan tarayıcıda çalıştırmanıza olanak tanır. Sunucu tarafında derlenen .wasm binary dosyası, istemci tarafında JavaScript runtime ile yüklenir ve çalıştırılır — hiçbir eklenti veya kurulum gerekmez.

WASM desteği, aşağıdaki seçenekleri sunar:

Komut satırı: tonyukuk-derle --backend=llvm -hedef wasm ile .wasm binary üretin
Çevrimiçi Playground: Tarayıcıdan kod yazıp WASM olarak derleyip çalıştırın
API: POST /api/compile-wasm endpoint'i ile programatik derleme
JS Runtime: TonyukukWasm sınıfı ile kendi web sayfanıza entegre edin

Mimari

Tonyukuk WASM derleme süreci şu adımlardan oluşur:

  Tonyukuk        LLVM IR         LLVM            wasm-ld-17        Tarayıcı
  Kaynak Kodu  ──▶  (.ll)    ──▶  Object   ──▶    (.wasm)     ──▶  WebAssembly
  (program.tr)                    (.o)             Binary           .instantiate()

Ayrıştırma: Tonyukuk kaynak kodu sözdizimsel olarak ayrıştırılır (parse) ve AST oluşturulur
LLVM IR Üretimi: AST, wasm32-unknown-unknown hedef üçlüsü ile LLVM IR'e dönüştürülür
Import Tanımları: JavaScript'ten sağlanacak fonksiyonlar (yazdırma, bellek yönetimi vb.) extern olarak tanımlanır
Nesne Dosyası: LLVM, IR'i .o (WebAssembly nesne) formatına derler
Bağlama: wasm-ld-17 ile nesne dosyası .wasm binary'ye bağlanır. Bellek düzeni, stack ve data segment'leri ayarlanır
Çalıştırma: Tarayıcıda WebAssembly.instantiate() ile yüklenir, import nesnesi sağlanır ve main() çağrılır

Bağlama aşamasında kullanılan wasm-ld-17 parametreleri:

Parametre	Açıklama
`--no-entry`	`_start` yerine `main()` export edilir
`--export-all`	Tüm fonksiyonlar dışa aktarılır
`--allow-undefined`	Import fonksiyonları (yazdırma vb.) tanımsız kalabilir
`--import-memory`	Bellek JavaScript tarafından sağlanır
`--initial-memory=1048576`	Başlangıç bellek: 1 MB (16 sayfa)
`--max-memory=16777216`	Maksimum bellek: 16 MB (256 sayfa)
`--stack-first`	Stack, belleğin başına yerleştirilir

WASM Derleme (Komut Satırı)

Komut satırından WASM binary üretmek için:

# LLVM backend ile .wasm binary üret
$ tonyukuk-derle --backend=llvm -hedef wasm program.tr -o program.wasm

# Üretilen WASM'ı WAT formatında incele
$ wasm2wat program.wasm -o program.wat
$ cat program.wat

# WAT'tan WASM'a geri dönüştür
$ wat2wasm program.wat -o program2.wasm

Native WASM backend ile doğrudan WAT (WebAssembly Text Format) de üretebilirsiniz:

# Native backend ile WAT üret
$ tonyukuk-derle -hedef wasm program.tr -o program.wat

Fark: LLVM backend binary .wasm dosyası üretir (tarayıcıda doğrudan çalışır). Native backend ise metin formatlı .wat dosyası üretir (debug/inceleme için faydalıdır).

Gerekli araçlar:

Araç	Paket	Kurulum
`wasm-ld-17`	lld-17	`sudo apt install lld-17`
`wasm2wat`	wabt	`sudo apt install wabt`
`wat2wasm`	wabt	`sudo apt install wabt`

JavaScript Runtime (TonyukukWasm)

Tonyukuk, tarayıcıda WASM çalıştırmak için hazır bir JavaScript runtime sağlar: TonyukukWasm sınıfı. Bu sınıf derleme, yükleme ve çalıştırma işlemlerini tek bir API altında birleştirir.

<!-- Sayfanıza ekleyin -->
<script src="/wasm/tonyukuk.js"></script>

Temel Kullanım

// TonyukukWasm örneği oluştur
const tonyukuk = new TonyukukWasm();

// Çıktı callback'i — her yazdır() çağrısında tetiklenir
tonyukuk.ciktiCallback = function(metin) {
    document.getElementById('cikti').textContent += metin;
};

// Kod yaz ve çalıştır
const kod = 'yazdır("Merhaba WASM!")';
const sonuc = await tonyukuk.calistir(kod);
console.log(sonuc);  // "Merhaba WASM!\n"

API Referansı

Metot	Parametreler	Dönüş	Açıklama
`calistir(kod)`	`kod: string`	`Promise<string>`	Kodu derle + yükle + çalıştır. Tüm çıktıyı string olarak döndürür.
`derle(kod)`	`kod: string`	`Promise<ArrayBuffer>`	Kodu sunucuda WASM'a derle, binary'yi döndür. Çalıştırmaz.
`yukle(wasm_ikili)`	`wasm_ikili: ArrayBuffer`	`Promise<void>`	WASM binary'yi `WebAssembly.instantiate()` ile yükle.
`metin_oku(ptr, len)`	`ptr: number, len: number`	`string`	WASM belleğinden UTF-8 string oku (offset + uzunluk).
`metin_oku_c(ptr)`	`ptr: number`	`string`	WASM belleğinden C-style null-terminated string oku.
`bellek_bilgisi()`	—	`{bayt, kb, mb}`	WASM bellek kullanım bilgisi.

Özellikler

Özellik	Tip	Açıklama
`ciktiCallback`	`function(metin)`	Her yazdır() çağrısında tetiklenen callback. `null` ise çıktı tamponlanır.
`ornek`	`WebAssembly.Instance`	Yüklenen WASM örneği (yüklemeden sonra erişilebilir).
`bellek`	`WebAssembly.Memory`	Paylaşılan WASM belleği (16 sayfa başlangıç, 256 sayfa max).
`disa_aktarimlar`	`object`	WASM'ın dışa aktardığı fonksiyonlar (main, memory vb.).

İleri Kullanım: Adım Adım Derleme ve Çalıştırma

const tonyukuk = new TonyukukWasm();

// 1. Adım: Sadece derle (henüz çalıştırma)
const wasmBinary = await tonyukuk.derle(`
işlev topla(a: tam, b: tam) -> tam
    döndür a + b
son
yazdır(topla(3, 4))
`);

console.log('WASM boyutu:', wasmBinary.byteLength, 'bayt');

// 2. Adım: Yükle
await tonyukuk.yukle(wasmBinary);

// 3. Adım: Export'ları incele
console.log('Export edilen fonksiyonlar:',
    Object.keys(tonyukuk.disa_aktarimlar));

// 4. Adım: Çalıştır
tonyukuk.disa_aktarimlar.main();

// 5. Adım: Bellek bilgisi
const bellek = tonyukuk.bellek_bilgisi();
console.log(`Bellek: ${bellek.kb} KB / ${bellek.mb} MB`);

Import Fonksiyonları

WASM modülü, bazı fonksiyonları JavaScript tarafından sağlanan import'lardan çağırır. Tonyukuk derleyicisi aşağıdaki import'ları kullanır:

Yazdırma Fonksiyonları

Import Adı	İmza	Tonyukuk Karşılığı	Açıklama
`_yazdir_tam`	`(i64) → void`	`yazdır(42)`	Tamsayı yazdır + yeni satır
`_yazdir_metin`	`(i32 ptr, i32 len) → void`	`yazdır("metin")`	UTF-8 metin yazdır (işaretçi + uzunluk)
`_yazdir_ondalik`	`(f64) → void`	`yazdır(3.14)`	Ondalık sayı yazdır + yeni satır
`puts`	`(i32 ptr) → i32`	—	C uyumluluğu: null-terminated string yazdır

Bellek Yönetimi

Import Adı	İmza	Açıklama
`memory`	`WebAssembly.Memory`	JavaScript'ten sağlanan paylaşılan bellek (16-256 sayfa)
`__bellek_buyut`	`(i32 sayfa) → i32`	Belleği belirtilen sayfa kadar büyüt

Matematik Fonksiyonları

Import Adı	JavaScript Karşılığı
`Math_sin`, `Math_cos`, `Math_tan`	`Math.sin()`, `Math.cos()`, `Math.tan()`
`Math_sqrt`, `Math_pow`, `Math_abs`	`Math.sqrt()`, `Math.pow()`, `Math.abs()`
`Math_floor`, `Math_ceil`, `Math_round`	`Math.floor()`, `Math.ceil()`, `Math.round()`
`Math_log`, `Math_exp`	`Math.log()`, `Math.exp()`

Yardımcı Fonksiyonlar

Import Adı	İmza	Açıklama
`rastgele`	`() → f64`	0.0-1.0 arası rastgele sayı (`Math.random()`)
`zaman_damgasi`	`() → i64`	Unix zaman damgası milisaniye cinsinden (`Date.now()`)
`exit`	`(i32 kod) → void`	Programı sonlandır. Sıfır dışı kodlar çıktıya yazılır.

Kendi Import Nesnenizi Yazma

TonyukukWasm sınıfını kullanmadan, kendi import nesnenizi yazarak WASM'ı doğrudan yükleyebilirsiniz:

const bellek = new WebAssembly.Memory({ initial: 16, maximum: 256 });
const cozucu = new TextDecoder('utf-8');

const ice_aktarimlar = {
    env: {
        memory: bellek,

        // Tamsayı yazdır
        _yazdir_tam: function(deger) {
            console.log(String(deger));
        },

        // Metin yazdır (işaretçi + uzunluk)
        _yazdir_metin: function(ptr, len) {
            const buf = new Uint8Array(bellek.buffer);
            console.log(cozucu.decode(buf.subarray(ptr, ptr + len)));
        },

        // Ondalık sayı yazdır
        _yazdir_ondalik: function(deger) {
            console.log(String(deger));
        },

        // C string yazdır (puts uyumluluğu)
        puts: function(ptr) {
            const buf = new Uint8Array(bellek.buffer);
            let len = 0;
            while (buf[ptr + len] !== 0) len++;
            console.log(cozucu.decode(buf.subarray(ptr, ptr + len)));
            return 0;
        }
    }
};

// WASM dosyasını yükle ve çalıştır
const yanit = await fetch('program.wasm');
const ikili = await yanit.arrayBuffer();
const { instance } = await WebAssembly.instantiate(ikili, ice_aktarimlar);

instance.exports.main();

Önemli: WASM i64 değerleri JavaScript'te BigInt olarak gelir. BigInt + "metin" hata verir! Yazdırırken mutlaka String(deger) kullanın.

Playground ile WASM Çalıştırma

Tonyukuk'un çevrimiçi playground'u, kod yazmak için en hızlı yoldur. WASM modu ile derlenen kod sunucuya gönderilir, .wasm binary olarak derlenir ve tarayıcınızda çalıştırılır.

Kullanım:

tonyukuktr.com adresine gidin veya playground sayfasını açın
“Backend” seçicisinden WASM (Tarayıcıda) seçin
Kodunuzu yazın ve Çalıştır butonuna tıklayın
Çıktı, çıktı panelinde görünecektir

WASM modunun farkları:

Kod sunucuda derlenir ama tarayıcınızda çalışır (sunucuda değil)
Çıktı, JavaScript TonyukukWasm runtime'ı aracılığıyla toplanır
Native/LLVM modlarından farklı olarak, program tarayıcı sandbox'unda izole çalışır
Dosya sistemi, ağ erişimi veya sistem çağrıları desteklenmez

İpucu: Playground'da “LLVM” backend seçip “IR Göster” kutusunu işaretleyerek kodunuzun LLVM IR çıktısını da görebilirsiniz. Bu, derleyicinin kodunuzu nasıl dönüştürdüğünü anlamak için faydalıdır.

WASM Derleme API'si

Tonyukuk, programatik WASM derleme için bir HTTP API sunar. Bu API'yi kendi uygulamalarınıza entegre edebilirsiniz.

POST /api/compile-wasm

Parametre	Tip	Açıklama
`kod`	`string`	Tonyukuk kaynak kodu (URL-encoded)

Başarılı yanıt:

Header	Değer
`Content-Type`	`application/wasm`
`Content-Length`	Binary boyutu (bayt)
Gövde	WASM binary verisi

Hata yanıtı: HTTP 400 + düz metin hata mesajı

# curl ile WASM derleme
$ curl -X POST https://tonyukuktr.com/api/compile-wasm \
    -d 'kod=yazdır("Merhaba!")' \
    --output program.wasm

# Sonucu doğrula
$ file program.wasm
program.wasm: WebAssembly (wasm) binary module version 0x1

$ wasm2wat program.wasm | head -5

// JavaScript ile API kullanımı
const yanit = await fetch('/api/compile-wasm', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: 'kod=' + encodeURIComponent('yazdır(42)')
});

if (yanit.ok) {
    const wasm = await yanit.arrayBuffer();
    console.log('WASM boyutu:', wasm.byteLength, 'bayt');
} else {
    const hata = await yanit.text();
    console.error('Derleme hatası:', hata);
}

Sınırlamalar:

Parametre	Limit
Kaynak kod boyutu	Maksimum 8 KB
WASM çıktı boyutu	Maksimum 512 KB
Derleme zaman aşımı	15 saniye

Kapsamlı WASM Örnekleri

1. Merhaba Dünya

En basit WASM programı:

# merhaba_wasm.tr
yazdır("Merhaba Dünya!")
yazdır("Bu kod tarayıcıda çalışıyor!")

# Derleme
$ tonyukuk-derle --backend=llvm -hedef wasm merhaba_wasm.tr -o merhaba.wasm

# Boyut kontrolü
$ ls -la merhaba.wasm
-rw-r--r-- 1 user user 847 ... merhaba.wasm

Beklenen çıktı:

Merhaba Dünya!
Bu kod tarayıcıda çalışıyor!

2. Döngü ile Fibonacci Serisi

Döngü yapısının WASM'da nasıl çalıştığını gösteren örnek:

# fibonacci.tr — Fibonacci serisinin ilk 11 elemanı
işlev fib(n: tam) -> tam
    eğer n <= 1 ise
        döndür n
    son
    döndür fib(n - 1) + fib(n - 2)
son

döngü i = 0, 10 ise
    yazdır(fib(i))
son

Beklenen çıktı:

3. Faktöriyel Hesaplama

Rekürsif fonksiyon ve döngü birlikte:

# faktoriyel.tr
işlev fakt(n: tam) -> tam
    eğer n <= 1 ise
        döndür 1
    son
    döndür n * fakt(n - 1)
son

döngü i = 1, 10 ise
    yazdır(fakt(i))
son

Beklenen çıktı:

4. Kareleri Yazdırma

Döngü içinde aritmetik işlem:

# kareler.tr — 1'den 8'e kadar kareleri yazdır
döngü i = 1, 8 ise
    yazdır(i * i)
son

Beklenen çıktı:

5. Koşullu Mantık

Eğer/değilse yapısının WASM'da çalışması:

# kosullu.tr
işlev mutlak(x: tam) -> tam
    eğer x < 0 ise
        döndür 0 - x
    son
    döndür x
son

yazdır(mutlak(5))
yazdır(mutlak(-3))
yazdır(mutlak(0))

Beklenen çıktı:

5
3
0

6. İç İçe Döngüler

# ic_ice.tr — Çarpım tablosu (1-5)
döngü i = 1, 5 ise
    döngü j = 1, 5 ise
        yazdır(i * j)
    son
son

JavaScript ile Tam Entegrasyon Örneği

Bir web sayfasında Tonyukuk WASM'ı kullanma:

<!DOCTYPE html>
<html>
<head>
    <title>Tonyukuk WASM Örneği</title>
</head>
<body>
    <textarea id="kod" rows="10" cols="50">
yazdır("Merhaba WASM!")
döngü i = 1, 5 ise
    yazdır(i * i)
son
    </textarea>
    <button onclick="calistir()">Çalıştır</button>
    <pre id="cikti"></pre>

    <script src="https://tonyukuktr.com/wasm/tonyukuk.js"></script>
    <script>
    async function calistir() {
        const ciktiEl = document.getElementById('cikti');
        const kod = document.getElementById('kod').value;
        ciktiEl.textContent = 'Derleniyor...';

        const tw = new TonyukukWasm();
        tw.ciktiCallback = function(metin) {
            if (ciktiEl.textContent === 'Derleniyor...') {
                ciktiEl.textContent = '';
            }
            ciktiEl.textContent += metin;
        };

        try {
            await tw.calistir(kod);
            const bellek = tw.bellek_bilgisi();
            ciktiEl.textContent += `\n[Bellek: ${bellek.kb} KB]`;
        } catch(e) {
            ciktiEl.textContent = 'Hata: ' + e.message;
        }
    }
    </script>
</body>
</html>

Bellek Yönetimi

WASM modülleri doğrusal (linear) bir bellek modeli kullanır. Tonyukuk WASM runtime'ı şu bellek yapılandırmasını kullanır:

Parametre	Değer	Açıklama
Başlangıç boyut	16 sayfa (1 MB)	Program başlatıldığında ayrılan bellek
Maksimum boyut	256 sayfa (16 MB)	Büyüyebileceği üst sınır
Sayfa boyutu	64 KB	WebAssembly standart sayfa boyutu
Stack konumu	Belleğin başı	`--stack-first` ile ayarlanır

Bellek düzeni:

  0x00000    ┌──────────────────┐
             │    Stack          │  ← Fonksiyon çağrı yığını
  0x10000    ├──────────────────┤
             │    Data Segment   │  ← String sabitleri, global değişkenler
             ├──────────────────┤
             │    Heap           │  ← Dinamik bellek ayırma
             ├──────────────────┤
             │    (Boş)          │  ← Büyüme alanı
  max        └──────────────────┘

JavaScript'ten bellek durumunu sorgulayabilirsiniz:

const tw = new TonyukukWasm();
await tw.calistir(kod);

const bilgi = tw.bellek_bilgisi();
console.log(`Bellek: ${bilgi.bayt} bayt (${bilgi.kb} KB / ${bilgi.mb} MB)`);

// Ham bellekten veri okuma
const gorunum = new Uint8Array(tw.bellek.buffer);
console.log('İlk 16 bayt:', gorunum.slice(0, 16));

Not: WASM sandbox ortamında çalıştığı için, programlar dosya sistemi, ağ veya sistem çağrılarına erişemez. Yalnızca saf hesaplama ve yazdırma desteklenir.

Hata Ayıklama (Debug)

LLVM backend, DWARF format debug bilgisi üretir. Bu sayede GDB, LLDB gibi hata ayıklayıcılarla kodunuzu adım adım izleyebilirsiniz.

Debug Bilgisi ile Derleme

$ tonyukuk-derle --backend=llvm -g program.tr -o program

GDB ile Hata Ayıklama

$ gdb ./program
(gdb) break main
(gdb) run
(gdb) list              # Kaynak kodu göster
(gdb) print degisken    # Değişken değeri
(gdb) next              # Sonraki satır
(gdb) step              # Fonksiyona gir
(gdb) bt                # Çağrı yığını

LLDB ile Hata Ayıklama

$ lldb ./program
(lldb) breakpoint set --name main
(lldb) run
(lldb) source list
(lldb) frame variable

Debug Bilgisi Doğrulama

# DWARF bilgisini görüntüle
$ objdump --dwarf=info program | head -50

# Fonksiyon/satır eşlemesi
$ llvm-dwarfdump --name=main program

Üretilen Debug Metadata

Debug bilgisi şunları içerir:

DICompileUnit: Derleme birimi (kaynak dosya, derleyici)
DISubprogram: Fonksiyon bilgisi (isim, satır, tip)
DILocation: Satır/sütun konumu
DILocalVariable: Yerel değişken bilgisi

Örnek IR debug metadata:

!0 = distinct !DICompileUnit(language: DW_LANG_C,
       file: !1, producer: "Tonyukuk Derleyici")
!1 = !DIFile(filename: "program.tr", directory: ".")
!4 = distinct !DISubprogram(name: "topla",
       file: !1, line: 4, type: !5)