Jifunze Swa

Hatua 1 — Programu ya kwanza

Faili ya .swa ni mfuatano wa matamko ya kiwango cha juu: kazi, miundo, na vigezo vya ulimwengu. Sehemu ya kuingia ni kazi main — katika hali ya --exe, sahihi ni N32 main() au N32 main(N32 argc, N8** argv).

Hii ni programu ya kwanza kabisa:

N32 main() {
    andika("Habari, Swa!\n");
    rudisha 0;
}

Ili kuendesha, maktaba ya kumbukumbu huunganishwa kwanza kwa cat — andika inatoka hapo, si kwenye mkusanyaji:

cat msingi/kumbukumbu.swa hello.swa > hello_zima.swa
./msingi/mbegu.bin --exe hello_zima.swa > hello.bin
chmod +x hello.bin && ./hello.bin

Hatua 2 — Aina na vigezo

Familia tano za aina za nambari, kila moja ikifuatiwa na upana wa tarakimu:

Halisi: nambari kamili kama 25 — aina yake ya chaguo-msingi ni N32 ikiwa inatoshea ndani ya 32-bit yenye ishara, vinginevyo N64. Desimali kama 21.5 — D64. Mfuatano kama "habari" — baiti za N8 zikifuatiwa na 0; utorokaji \n, \t, \\, \" unasaidiwa. Maoni: // na /* ... */; maoni ya kijiuzi hayaruhusiwi.

Hakuna maneno kweli, uongo, wala tupu: ukweli ni 1, si kweli ni 0; matokeo ya ulinganisho ni 1 au 0. Vigezo vya ulimwengu na safu za ulimwengu vinaruhusiwa (N32 KIKOMO = 0;, N8 bafa[1024];).

N32 umri = 25;
N64 idadi_ya_watu = 8000000000;
N8 herufi = 65;

N32 main() {
    D64 wastani = 3.14;
    kama (umri != 25) { rudisha 1; }
    kama (herufi != 65) { rudisha 2; }
    kama (wastani > 3.0) {
        rudisha 0;
    }
    rudisha 3;
}

Programu hii haichapishi chochote: inarudi msimbo 0 ikiwa kila kigezo kinashikilia thamani yake sahihi.

Hatua 3 — Mtiririko wa udhibiti

kama (sharti) { ... } na sivyo { ... } (hiari). Tawi-jingine huandikwa kwa kuingiza kama ndani ya sivyo — hakuna maneno kamasivyo wala sivyo kama.

wakati (sharti) { ... } ni kitanzi. kwa (kianzilishi; sharti; hatua) { ... } — sehemu zote tatu ni za hiari. Semantiki ya endelea ndani ya kwa: inaruka hadi HATUA (ya tatu), si kwenye sharti — semantiki ya C. vunja; inatoka nje ya kitanzi cha ndani; endelea; inaruka hadi mwisho wa mwili wa kitanzi.

&& na || zinatathmini kwa fupi-hali: a && b haitathmini b ikiwa a ni 0 — hii inaruhusu j >= 0 && a[j] == x bila kusoma nje ya mipaka. Opereta ya ternary sharti ? kweli : uwongo inasaidiwa.

N32 jumla_kwa_kwa(N32 n) {
    N32 s = 0;
    kwa (N32 i = 0; i < n; i = i + 1) {
        kama (i == 3) { endelea; }
        kama (i == 8) { vunja; }
        s = s + i;
    }
    rudisha s;
}

N32 main() {
    N32 x = -4;
    N32 hali = 0;
    kama (x > 0) {
        hali = 1;
    } sivyo {
        kama (x < 0) {
            hali = -1;
        }
    }
    N32 n = 0;
    wakati (n < 3) {
        n = n + 1;
    }
    andika("wakati: %d, kwa: %d\n", n, jumla_kwa_kwa(10));
    kama (hali != -1) { rudisha 1; }
    rudisha 0;
}

jumla_kwa_kwa(10) ni 0+1+2+4+5+6+7 = 25: i = 3 imerukwa na endelea, na i = 8 imevunja kitanzi — semantiki ya C ya endelea ndani ya kwa.

Hatua 4 — Kazi

Umbo: <aina> <jina>(<vigezo>) { <mwili> }. Vigezo hupitishwa kwa thamani au kwa kielekezi. rudisha <usemi>; kwa kazi yenye thamani; rudisha; kwa W0. Wito wa mbele unaruhusiwa (kazi inaweza kuitwa kabla ya kutangazwa); kujirudia kunasaidiwa.

N32 jumlisha(N32 a, N32 b) {
    rudisha a + b;
}

W0 salamu(N8* jina) {
    andika("Habari, %s!\n", jina);
}

N32 main() {
    salamu("Dunia");
    rudisha jumlisha(3, 4);
}

Programu inarudi msimbo 7 — matokeo ya jumlisha(3, 4) — ukionyesha kwamba kurejesha thamani kunafanya kazi.

Kujirudia ni rahisi kama C:

N32 fibonacci(N32 n) {
    kama (n <= 1) { rudisha n; }
    rudisha fibonacci(n - 1) + fibonacci(n - 2);
}

N32 main() {
    N32 n = 10;
    andika("fibonacci(%d) = %d\n", n, fibonacci(n));
    rudisha 0;
}

Hatua 5 — Miundo

muundo Nukta { N32 x; N32 y; }; — upatikanaji wa sehemu kwa p.x (thamani) na p->x (kielekezi). Miundo inaweza kupitishwa kwa thamani na kurejeshwa kwa thamani (sret imetekelezwa). Hakuna urithi, hakuna miundo ya kijiuzi.

muundo Nukta {
    N32 x;
    N32 y;
};

N32 pata_x(Nukta* p) {
    rudisha p->x;
}

W0 weka_x(Nukta* p, N32 v) {
    p->x = v;
}

N32 main() {
    Nukta n;
    n.x = 3;
    n.y = 9;
    weka_x(&n, 12);
    andika("x = %d, jumla = %d\n", n.x, n.x + n.y);
    rudisha pata_x(&n);
}

Hatua 6 — Vielekezi na safu

&x — anwani ya kigezo au sehemu ya muundo; *p — nyoosha; p->sehemu — sehemu kupitia kielekezi; a[i] — ni *(a + i * ukubwa_wa_kipengele); usemi wa safu pekee hutathminiwa kama kielekezi kwa kipengele chake cha kwanza.

W0 badilishana(N32* a, N32* b) {
    N32 t = *a;
    *a = *b;
    *b = t;
}

N32 main() {
    N32 x = 3;
    N32 y = 8;
    andika("kabla: x = %d, y = %d\n", x, y);
    badilishana(&x, &y);
    andika("baada: x = %d, y = %d\n", x, y);
    rudisha 0;
}

Safu za ndani, safu za ulimwengu, na vianzishi vya safu (N32 namba[5] = {1, 2, 3, 4, 5};) zinasaidiwa:

N32 main() {
    N32 safu[5];
    N32 i = 0;
    wakati (i < 5) {
        safu[i] = i * 10;
        i = i + 1;
    }
    N32 jumla = 0;
    i = 0;
    wakati (i < 5) {
        jumla = jumla + safu[i];
        i = i + 1;
    }
    andika("jumla: %d, safu[3]: %d\n", jumla, safu[3]);
    rudisha 0;
}

Hatua 7 — Kumbukumbu na mifumo

tenga(ukubwa) hutenga kumbukumbu; achilia(p) huachilia; badili(p, ukubwa) hupanua kipande (inayolingana na realloc). ukubwa(T) hutoa ukubwa wa aina kwa baiti.

Kwa mifumo: wito_wa_mfumo(namba, a1, ..., a6) ni simu ya syscall ya Linux moja kwa moja (ABI: rax, rdi, rsi, rdx, r10, r8, r9). tekeleza(N8* kazi, N32 argc, N8** argv, N32 ofseti) hutekeleza msimbo wa JIT; anwani_ya_kazi(N8* jina) hutoa anwani ya kazi ya ndani.

N32 main() {
    N8* p = tenga(8);
    kama (p == 0) { rudisha 1; }
    p[0] = 42;
    andika("thamani: %d\n", p[0]);
    achilia(p);
    rudisha 0;
}

Hatua 8 — Maktaba ya kawaida

Maktaba ya kawaida iko kwenye msingi/ na imeandikwa kwa Swa yenyewe. Moduli tisa za watumiaji, kwa kila moja kile inachotoa kweli:

Mfano wa mfuatano — angalia: faili mbili za maktaba huunganishwa kwa cat:

N32 main() {
    N8 b[16];
    nakili_mfuatano(b, "habari");
    andika("urefu: %d\n", urefu_wa_mfuatano(b));
    rudisha 0;
}

Na safari kamili ya mifuatano — kunakili, kulinganisha, kutafuta, kugeuza, na kubadili nambari hadi mfuatano:

N32 main() {
    N8 b[32];
    nakili_mfuatano(b, "habari");
    andika("urefu: %d\n", urefu_wa_mfuatano(b));
    andika("linganisho na habari: %d\n", linganisha_mfuatano(b, "habari"));
    andika("herufi b iko faharisi: %d\n", tafuta_herufi(b, 98));
    geuza_mfuatano(b);
    andika("geuzi: %s\n", b);
    N8 namba[16];
    nambari_kwa_mfuatano(1234, namba);
    andika("namba: %s\n", namba);
    rudisha 0;
}

Hatua 9 — Kuendesha programu

Njia ya uzalishaji ni mnyororo wa mbegu/exe — bila Rust, LLVM, clang, wala libc. Programu zinazotumia maktaba huunganishwa kwa cat kwanza:

cat msingi/kumbukumbu.swa msingi/mfuatano.swa sampuli.swa > sampuli_zima.swa
./msingi/mbegu.bin --exe sampuli_zima.swa > sampuli.bin
chmod +x sampuli.bin && ./sampuli.bin

Au kujenga mkusanyaji kamili wa .swa (stage1-exe) kutoka chanzo, kisha kuitumia kwa programu zako:

cat msingi/kumbukumbu.swa msingi/mfuatano.swa msingi/msomaji.swa \
    msingi/msambazaji.swa msingi/mteremko.swa msingi/mkaguzi.swa \
    msingi/uzalishaji.swa msingi/orodha.swa msingi/ramani.swa \
    msingi/stage1.swa > zima.swa
./msingi/mbegu.bin --exe zima.swa > stage1-exe
chmod +x stage1-exe
./stage1-exe --exe programu.swa > programu.bin
chmod +x programu.bin && ./programu.bin

Dereva wa zamani wa Rust/LLVM (kande) umehamishiwa hazina ya kumbukumbu lugha-swa/swa-dereva (2026-09-05). Hazina kuu ina lugha moja tu: Swa.