Systém maker v programovacím jazyku C3

Obsah

1. Systém maker v programovacím jazyku C3

2. Makra ve vyšších programovacích jazycích

3. Definice a expanze jednoduchého makra

4. Expanze makra pro hodnoty různých datových typů

5. Problematika závorek v klasických céčkovských makrech vs. makra v C3

6. Uzávorkování parametrů makra v céčku

7. Makro expandované ve složitějším výrazu: varianta pro jazyk C3

8. Makro expandované ve složitějším výrazu: varianta pro jazyk C

9. Specifikace datových typů v definici makra

10. Pokus o expanzi makra s předáním parametrů nekorektních typů

11. Makra expandovaná do konstantních výrazů

12. Parametry makra vyhodnocované v době překladu

13. Předání jména proměnné nebo složitějšího výrazu do argumentu začínajícího znakem $

14. Pokus o definici makra, které prohodí obsah dvou proměnných

15. Druhá varianta makra pro prohození obsahu dvou proměnných

16. Potenciálně nebezpečná makra

17. Makro s proměnným počtem argumentů

18. Obsah navazujícího článku

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Systém maker v programovacím jazyku C3

Programovací jazyk C3 patří do stejné niky programovacích jazyků, ve které se nachází i jazyk C. Céčkovské programovací jazyky jsou vybaveny makrosystémem, tj. je v nich možné vytvářet makra, která jsou při svém volání expandována a namísto volání makra se do zdrojového kódu vloží jeho expandovaná podoba. Jak v jazyku C tak i v C++ tato expanze probíhá ještě před vlastním překladem (ten začíná parsingem), což znamená, že při expanzi maker není kontrolována ani syntaxe ani korektnost datových typů; navíc je většinou nutné parametry makra i jeho tělo správně „uzávorkovat“, takže používání maker je relativně nebezpečná operace. V jazyku C3 je situace odlišná, protože v něm lze vytvářet bezpečnější makra (navíc i s volitelnou podporou datových typů); na druhou stranu jsou však k dispozici i složitější konstrukce „nebezpečných“ maker, tj. maker, ve kterých se může měnit tok běhu programu atd. Dnes se seznámíme se základy tohoto systému a porovnáme možnosti C3 s původním céčkem.

2. Makra ve vyšších programovacích jazycích

V programovacích jazycích C, C++, ale například i v m4 se makra používají pro „pouhé“ provádění textových substitucí prováděných typicky v průběhu načítání zdrojových kódů, zatímco makrosystém implementovaný v jazyku C3 je založen na modifikaci AST, což na jednu stranu umožňuje mnohem hlubší zásahy do kódu, na stranu druhou jsou makra bezpečnější. V tomto ohledu má jazyk C3, podobně jako jazyk Rust, poměrně blízko k LISPovským jazykům, v nichž je většinou makrosystém prakticky nedílnou součástí programovacího jazyka, protože jsou v něm realizovány mnohdy i základní programové konstrukce (navíc je LISP homoikonickým jazykem, což situaci dále zjednodušuje). Asi nejtypičtějším příkladem použití maker v LISPu je makro loop použité v Common Lispu (na druhou stranu někteří vývojáři soudí, že podobná makra zbytečně do Common Lispu přidávají imperativní kód, to je ovšem oblast přesahující téma dnešního článku). Některé vlastnosti tohoto makra jsou popsány na stránce http://www.ai.sri.com/pkar­p/loop.html. Podobným způsobem se s makry pracuje i v dalších jazycích založených na LISPu; příkladem je Clojure.

V programovacím jazyku C3 se navíc při definici makra a popř. při jeho expanzi provádí kontroly, zda jsou použity korektní datové typy, což je oproti jazykům C/C++ (pouhá textová expanze) další výhoda.

3. Definice a expanze jednoduchého makra

Způsob využití makrosystému programovacího jazyka C3 lze nejlépe vysvětlit na praktických příkladech. Podívejme se například na to, jakým způsobem je možné definovat makro nazvané add, které je určené pro výpočet součtu dvou hodnot. Jedná se o makro, které vrací nějakou hodnotu a proto bude expandováno do formy výrazu. Bude ho tedy možné použít všude tam, kde se očekává výraz:

macro add(x, y)
{
    return x+y;
}

Příklad použití makra:

module macros;
 
import std::io;
 
macro add(a, b)
{
    return a+b;
}
 
fn void main()
{
    int x = 1;
    int y = 2;
 
    io::printf("%d + %d = %d\n", x, y, add(x, y));
}

Po překladu a spuštění tohoto demonstračního příkladu se (podle očekávání) vypočte hodnota 3:

1 + 2 = 3

4. Expanze makra pro hodnoty různých datových typů

Makro add, které jsme definovali, nemá specifikováno, jakého typu mohou být jeho parametry. Z tohoto pohledu se makro chová jako funkce s generickými typy, která je volána v čase překladu. To ovšem znamená, že můžeme makro add zavolat s předáním hodnot libovolného typu, pro který je definován operátor součtu (+). To si ostatně můžeme velmi snadno ověřit ve druhém demonstračním příkladu, v němž pomocí makra sečteme dvě celočíselné hodnoty, následně dvě hodnoty s plovoucí řádovou čárkou a dokonce i prvky dvou vektorů:

module macros;
 
import std::io;
 
macro add(x, y)
{
    return x+y;
}
 
fn void main()
{
    int x = 1;
    int y = 2;
 
    io::printf("%d + %d = %d\n", x, y, add(x, y));
 
    float u = 1.1;
    float v = 2.2;
 
    io::printf("%f + %f = %f\n", u, v, add(u, v));
 
    int[<10>] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int[<10>] b = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
    io::printf("%s + %s = %s\n", a, b, add(a, b));
}

Výsledky ukazují, že expanze tohoto makra proběhla bez problému:

1 + 2 = 3
1.100000 + 2.200000 = 3.300000
[<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>] + [<1, 2, 3, 4, 5, 6, 7, 8, 9, 10>] = [<2, 4, 6, 8, 10, 12, 14, 16, 18, 20>]

5. Problematika závorek v klasických céčkovských makrech vs. makra v C3

V těle makra add nebyly použity žádné závorky, což může být z pohledu programátora, který je zvyklý na systém maker v jazyku C, poněkud matoucí. Mohlo by se dokonce zdát, že naše makro není napsáno korektně. Zkusme tedy namísto makra add nadefinovat makro mul určené pro součin dvou předaných výrazů:

macro mul(a, b)
{
    return a*b;
}

Toto makro zavoláme a předáme mu výrazy x+y:

int z = mul(x+y, x+y);

Otázkou je, která z následujících expanzí se provede:

x+y*x+y       // prostá textová expanze
(x+y)*(x+y)   // "inteligentní" expanze

To si snadno otestujeme předáním hodnot 1 a 2; pokaždé by se totiž měla vypočítat jiná hodnota:

1+2*1+2 = 5
(1+2)*(1+2) = 9

Otestujme si to:

module macros;
 
import std::io;
 
macro mul(a, b)
{
    return a*b;
}
 
fn void main()
{
    int x = 1;
    int y = 2;
 
    int z = mul(x+y, x+y);
 
    io::printf("%d\n", z);
}

Výsledkem bude zpráva:

9

V jazyku C3 tedy není nutné jednotlivé parametry makra závorkovat.

6. Uzávorkování parametrů makra v céčku

V programovacím jazyku C jsme většinou nuceni uzavřít v těle makra jména parametrů do závorek, protože C provádí pouze textovou substituci. Pokud na závorky zapomeneme, nemusí být provedené výpočty korektní. Otestujme si to na céčkové obdobě makra mul, ve kterém neprovedeme uzávorkování:

#include <stdio.h>
 
#define mul(a, b) a*b
 
void main(void)
{
    int x = 1;
    int y = 2;
 
    int z = mul(x+y, x+y);
 
    printf("%d\n", z);
}

Zdrojový kód bude po expanzi makra vypadat takto:

void main(void)
{
    int x = 1;
    int y = 2;
 
    int z = x+y*x+y;
 
    printf("%d\n", z);
}

Výsledkem bude nesprávná hodnota:

5

Oprava spočívá v ručním uzávorkování všech parametrů makra v jeho těle:

#include <stdio.h>
 
#define mul(a, b) (a)*(b)
 
void main(void)
{
    int x = 1;
    int y = 2;
 
    int z = mul(x+y, x+y);
 
    printf("%d\n", z);
}

Výsledek po expanzi makra:

void main(void)
{
    int x = 1;
    int y = 2;
 
    int z = (x+y)*(x+y);
 
    printf("%d\n", z);
}

Nyní bude vypočtený výsledek korektní:

9

7. Makro expandované ve složitějším výrazu: varianta pro jazyk C3

V programovacím jazyku C se u maker, které mohou být expandovány v rámci složitějšího výrazu, navíc uzavírá i celé tělo makra do závorek, aby bylo expandované makro do výsledného výrazu vloženo korektním způsobem. V jazyku C3 to však dělat nemusíme, o čemž se můžeme snadno přesvědčit překladem a spuštěním následujícího příkladu:

module macros;
 
import std::io;
 
macro add_mul(a, b)
{
    return a*b+1;
}
 
fn void main()
{
    int x = 1;
    int y = 2;
 
    int z = add_mul(x+y, x+y);
    int w = add_mul(x+y, x+y)*2;
 
    io::printf("%d\n", z);
    io::printf("%d\n", w);
}

Vypsané výsledky:

10
20

To znamená, že se provedou následující dva výpočty:

((1+2) * (1+2) + 1)
((1+2) * (1+2) + 1) * 2

a nikoli pouze:

(1+2) * (1+2) + 1
(1+2) * (1+2) + 1 * 2

8. Makro expandované ve složitějším výrazu: varianta pro jazyk C

V programovacím jazyku C, i když máme v makru správně uzávorkovány jednotlivé parametry, nebude expanze makra do složitějšího výrazu korektní, pokud celé tělo makra nebude uzávorkováno. V případě, že příklad z předchozí kapitoly přepíšeme do céčka, snadno zjistíme, proč tomu tak je:

#include <stdio.h>
 
#define add_mul(a, b) (a)*(b)+1
 
void main(void)
{
    int x = 1;
    int y = 2;
 
    int z = add_mul(x+y, x+y);
    int w = add_mul(x+y, x+y)*2;
 
    printf("%d\n", z);
    printf("%d\n", w);
}

Z výsledku expanze makra vyplývá, že skutečně chybí uzávorkování expandovaného těla makra:

void main(void)
{
    int x = 1;
    int y = 2;
 
    int z = (x+y)*(x+y)+1;
    int w = (x+y)*(x+y)+1*2;
 
    printf("%d\n", z);
    printf("%d\n", w);
}

V céčku je tedy nutné namísto:

a*b+1

tělo makra napsat (skoro LISPovským způsobem):

((a)*(b)+1)

Ověřme si to na upraveném příkladu:

#include <stdio.h>
 
#define add_mul(a, b) ((a)*(b)+1)
 
void main(void)
{
    int x = 1;
    int y = 2;
 
    int z = add_mul(x+y, x+y);
    int w = add_mul(x+y, x+y)*2;
 
    printf("%d\n", z);
    printf("%d\n", w);
}

Nyní bude výsledek expanze makra korektní:

void main(void)
{
    int x = 1;
    int y = 2;
 
    int z = ((x+y)*(x+y)+1);
    int w = ((x+y)*(x+y)+1)*2;
 
    printf("%d\n", z);
    printf("%d\n", w);
}

9. Specifikace datových typů v definici makra

V jazyku C3 je umožněno, aby se v definici makra (resp. v jeho hlavičce) mohly specifikovat typy parametrů makra. Tento přístup není v původním jazyku C vůbec možný, protože se překlad provádí až po textové expanzi maker.

Naše makro add přepíšeme do takové podoby, že bude akceptovat pouze parametry (konstanty či výrazy) typu int:

module macros;
 
import std::io;
 
macro add(int x, int y)
{
    return x+y;
}
 
fn void main()
{
    int x = 1;
    int y = 2;
 
    io::printf("%d + %d = %d\n", x, y, add(x, y));
}

Tento demonstrační příklad bude možné bez problémů přeložit i spustit:

1 + 2 = 3

10. Pokus o expanzi makra s předáním parametrů nekorektních typů

Nyní si ověřme, jak se bude překladač programovacího jazyka C3 chovat v případě, pokud budeme chtít makro expandovat s předáním parametrů jiných typů, než jsou celá čísla:

module macros;
 
import std::io;
 
macro add(int x, int y)
{
    return x+y;
}
 
fn void main()
{
    int x = 1;
    int y = 2;
 
    io::printf("%d + %d = %d\n", x, y, add(x, y));
 
    float u = 1.1;
    float v = 2.2;
 
    io::printf("%f + %f = %f\n", u, v, add(u, v));
 
    int[<10>] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int[<10>] b = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
    io::printf("%s + %s = %s\n", a, b, add(a, b));
}

Podle očekávání nebude v tomto případě možné expanzi makra provést, takže překlad skončí chybou (resp. hned dvěma chybami):

17:     float u = 1.1;
18:     float v = 2.2;
19:
20:     io::printf("%f + %f = %f\n", u, v, add(u, v));
                                               ^
(/home/ptisnovs/src/c3-examples/c3-macros/06_typed_macro.c3:20:44) Error: 'float' cannot implicitly be converted to 'int', but you may use a cast.

22:     int[<10>] a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
23:     int[<10>] b = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
24:
25:     io::printf("%s + %s = %s\n", a, b, add(a, b));
                                               ^
(/home/ptisnovs/src/c3-examples/c3-macros/06_typed_macro.c3:25:44) Error: You cannot cast 'int[<10>]' to 'int'.

11. Makra expandovaná do konstantních výrazů

Pokusme se makro add (nyní v jeho jednodušší podobě bez specifikace datových typů) použít při deklaraci konstanty. Makru taktéž předáváme konstanty, takže by to teoreticky mělo být možné:

module macros;
 
import std::io;
 
macro add(a, b)
{
    return a+b;
}
 
fn void main()
{
    const int X = 1;
    const int Y = 2;
 
    const int Z = add(X, Y);
 
    io::printf("%d + %d = %d\n", X, Y, Z);
}

Překladač jazyka C3 ovšem takovou expanzi makra nedovolí, resp. po expanzi zjistí, že výsledkem není (z jeho pohledu) konstanta:

12:     const int X = 1;
13:     const int Y = 2;
14:
15:     const int Z = add(X, Y);
                      ^^^^^^^^^
(/home/ptisnovs/src/c3-examples/c3-macros/07_compile_time_1.c3:15:19) Error: The expression must be a constant value.

Tatáž chyba bude ohlášena i tehdy, pokud do makra předáme přímo celočíselné konstanty:

12:     const int X = 1;
13:     const int Y = 2;
14:
15:     const int Z = add(1, 2);
                      ^^^^^^^^^
(/home/ptisnovs/src/c3-examples/c3-macros/07_compile_time_1.c3:15:19) Error: The expression must be a constant value.

12. Parametry makra vyhodnocované v době překladu

Aby bylo možné makro add použít i pro inicializaci pojmenované konstanty hodnotou, musí být tato hodnota vypočtena v čase překladu. Makro musíme v tomto případě upravit do takové podoby, že jeho argumenty budou mít před svým jménem zapsán prefix dolaru. Tím překladači jazyka C3 oznámíme, že argumenty budou vyhodnoceny v čase překladu a výsledkem našeho makra add tedy bude konstantní výraz 1+2, který je vypočten (v čase překladu) a do pojmenované konstanty Z je dosazena konstanta 3:

module macros;
 
import std::io;
 
macro add($a, $b)
{
    return $a+$b;
}
 
fn void main()
{
    const int X = 1;
    const int Y = 2;
 
    const int Z = add(X, Y);
 
    io::printf("%d + %d = %d\n", X, Y, Z);
}

13. Předání jména proměnné nebo složitějšího výrazu do argumentu začínajícího znakem $

Mohlo by se tedy zdát, že pokud před všechny argumenty makra přidáme znak dolaru, získáme „univerzální“ makro, které bude akceptovat jakékoli parametry a bude ho možné použít jak při volání funkce, tak i při definici konstanty. Ovšem ve skutečnosti tomu tak není, o čemž se můžeme snadno přesvědčit pokusem o překlad následujícího demonstračního příkladu:

module macros;
 
import std::io;
 
macro add($a, $b)
{
    return $a+$b;
}
 
fn void main()
{
    int x = 1;
    int y = 2;
 
    int z = add(x, y);
 
    io::printf("%d + %d = %d\n", x, y, z);
}

V tomto případě překladač jazyka C3 ohlásí chybu, která je vlastně opakem předchozí chyby. Nyní totiž makro voláme s předáním jmen proměnných, což z pohledu překladače jazyka C3 obecně nejsou konstanty (i když zrovna v tomto případě by si to překladač odvodit mohl):

12:     int x = 1;
13:     int y = 2;
14:
15:     int z = add(x, y);
                    ^
(/home/ptisnovs/src/c3-examples/c3-macros/09_compile_time_3.c3:15:17) Error: A compile time parameter must always be a constant, did you mistake it for a normal parameter?
 
 2:
 3: import std::io;
 4:
 5: macro add($a, $b)
          ^^^
(/home/ptisnovs/src/c3-examples/c3-macros/09_compile_time_3.c3:5:7) Note: The definition was here.

14. Pokus o definici makra, které prohodí obsah dvou proměnných

Pokusme se o vytvoření makra pojmenovaného swap, které v té části zdrojového kódu, kde bude zapsáno jeho volání (expanze), prohodí obsah dvou proměnných. Pokud by makra byla v jazyku C3 realizována formou textových substitucí (tedy tak, jako je tomu v jazyku C), bylo by řešení relativně jednoduché a mohlo by vypadat následovně:

module macros;
 
import std::io;
 
macro void swap(a, b)
{
    var temp = a;
    a = b;
    b = temp;
}
 
fn void main()
{
    int x = 1;
    int y = 2;
 
    swap(x, y);
 
    io::printf("%d, %d\n", x, y);
}

Tento demonstrační příklad je sice přeložitelný a spustitelný (neobsahuje tedy z pohledu překladače programovacího jazyka C3 syntaktické chyby), ovšem po jeho spuštění se vypíše:

1, 2

15. Druhá varianta makra pro prohození obsahu dvou proměnných

Aby bylo možné napsat korektní verzi makra swap pro prohození obsahu dvou proměnných, je nutné před parametry makra vložit znak # (hash). Tímto znakem se označuje symbol, který sice ještě není vyhodnocen, ale je vázán na místo, kde byl definován. V takovém případě bude makro expandováno podobně, jako je tomu v jazyku C.

V našem případě, pokud makro napíšeme následovně (pozor – ještě to není zcela korektní zápis):

macro void swap(#a, #b)
{
    var temp = #a;
    #a = #b;
    #b = temp;
}

A makro zavoláme stylem:

int x = 1;
int y = 2;
 
swap(x, y);

Provede překladač jazyka C3 expanzi makra do přibližně této podoby:

int x = 1;
int y = 2;
{
    int __temp = x;
    x = y;
    y = __temp;
}

16. Potenciálně nebezpečná makra

Ve skutečnosti nebude makro swap v takové podobě, v jaké jsme si ho ukázali v předchozí kapitole, přeložitelné. Operace, které bude toto makro provádět, jsou totiž potenciálně „nebezpečné“ (ovšem tím mocnější) a z tohoto důvodu překladač programovacího jazyka C3 vyžaduje, aby byl před jméno takového makra vložen znak zavináče:

macro void @swap(#a, #b)
{
    var temp = #a;
    #a = #b;
    #b = temp;
}

Zavináč se v tomto případě používá i při volání makra, aby bylo i v tomto místě zdrojového kódu zcela zřejmé, že se nejedná o volání běžné funkce, ale o potenciálně komplikovanější operaci:

int x = 1;
int y = 2;
 
@swap(x, y);

Vše si pochopitelně můžeme otestovat:

module macros;
 
import std::io;
 
macro void @swap(#a, #b)
{
    var temp = #a;
    #a = #b;
    #b = temp;
}
 
fn void main()
{
    int x = 1;
    int y = 2;
 
    @swap(x, y);
 
    io::printf("%d, %d\n", x, y);
}

Nyní by se již měl program přeložit a po jeho spuštění by se měly zobrazit hodnoty 2 a 1 (nikoli opačně):

2, 1

17. Makro s proměnným počtem argumentů

Překladač programovacího jazyka C3 umožňuje tvorbu (a pochopitelně i volání) maker s proměnným počtem argumentů. V hlavičce makra se tento proměnný počet argumentů označuje třemi tečkami:

macro int len(...)
{
    ...
    ...
    ...
}

V takovém makru jsou definovány symboly $vacount obsahující aktuální počet předaných argumentů, dále symbol $vaarg vracející vybraný argument tak, jakoby byl předán formou pozičního argumentu, $vaconst, který provádí podobnou činnost, ale pro konstantní argumenty, $vatype pro získání informace o typu n-tého argumentu a konečně symbol $vasplat využívaný například tehdy, pokud voláme jiný kód akceptující proměnný počet argumentů.

Podívejme se na velmi jednoduchý příklad, ve kterém je definováno makro vracející pouze počet předaných argumentů. Makro akceptuje libovolný počet argumentů a interně využívá symbol $vacount zmíněný v předchozím odstavci:

module macros;
 
import std::io;
 
macro int len(...)
{
    return $vacount;
}
 
fn void main()
{
    io::printf("%d\n", len(1, 2, 3, "foo", "bar", "baz"));
}

Po překladu a spuštění tohoto příkladu by se měla zobrazit hodnota:

6

18. Obsah navazujícího článku

V dnešním článku jsme si ukázali základy používání maker v jazyce C3, ovšem ve skutečnosti je makrosystém tohoto jazyka mnohem rozsáhlejší. Proto budeme v popisu makrosystému C3 pokračovat i v navazujícím článku, ve kterém si ukážeme komplikovanější makra, která již dokážou zasahovat do syntaxe zápisu zdrojových kódů (na druhou stranu se ovšem v žádném případě nedosahuje takových vyjadřovacích schopností, jaké má například makrosystém LISPovských jazyků).

19. Repositář s demonstračními příklady

Demonstrační příklady vytvořené pro nejnovější verzi programovacího jazyka C3 byly uloženy do repositáře dostupného na adrese https://github.com/tisnik/c3-examples. Následují odkazy na jednotlivé příklady (či jejich nedokončené části).

Demonstrační příklady z prvního článku o programovacím jazyku C3:

Demonstrační příklady ze druhého článku o jazyku C3:

Demonstrační příklady použité ve třetím článku o jazyku C3:

Demonstrační příklady ze čtvrtého o jazyku C3:

Demonstrační příklady z pátého článku o jazyku C3:

Následují odkazy na demonstrační příklady z článku předchozího:

Demonstrační příklady z předchozího článku o funkcích v C3:

20. Odkazy na Internetu

1. Programovací jazyk C3: evoluce, nikoli revoluce
   https://www.root.cz/clanky/pro­gramovaci-jazyk-c3-evoluce-nikoli-revoluce/
2. Programovací jazyk C3: datové typy pro moderní architektury
   https://www.root.cz/clanky/pro­gramovaci-jazyk-c3-datove-typy-pro-moderni-architektury/
3. Programovací jazyk C3: složené datové typy a kontejnery
   https://www.root.cz/clanky/pro­gramovaci-jazyk-c3-slozene-datove-typy-a-kontejnery/
4. The C3 Programming Language
   https://c3-lang.org/
5. C3 For C Programmers
   https://c3-lang.org/language-overview/primer/
6. C3 is a C-like language trying to be an incremental improvement over C rather than a whole new language
   https://www.reddit.com/r/Pro­grammingLanguages/comments/o­ohij6/c3_is_a_clike_langu­age_trying_to_be_an/
7. Tiobe index
   https://www.tiobe.com/tiobe-index/
8. PYPL PopularitY of Programming Language
   https://pypl.github.io/PYPL.html
9. C3 Tutorial
   https://learn-c3.org/
10. History of programming languages
    https://devskiller.com/history-of-programming-languages/
11. History of programming languages (Wikipedia)
    https://en.wikipedia.org/wi­ki/History_of_programming_lan­guages
12. D language
    https://dlang.org/
13. Zig programming language
    https://ziglang.org/
14. V language
    https://vlang.io/
15. D programming language
    https://en.wikipedia.org/wi­ki/D_(programming_language)
16. Zig programming language (Wikipedia)
    https://en.wikipedia.org/wi­ki/Zig_(programming_langu­age)
17. V programming language (Wikipedia)
    https://en.wikipedia.org/wi­ki/V_(programming_language)
18. Syntax highlighting for C3's programming language
    https://github.com/Airbus5717/c3.vim
19. Go factorial
    https://gist.github.com/e­simov/9622710
20. Generational list of programming languages
    https://en.wikipedia.org/wi­ki/Generational_list_of_pro­gramming_languages
21. The Language Tree: Almost Every Programming Language Ever Made
    https://github.com/Phileo­sopher/langmap
22. List of C-family programming languages
    https://en.wikipedia.org/wi­ki/List_of_C-family_programming_languages
23. Compatibility of C and C++
    https://en.wikipedia.org/wi­ki/Compatibility_of_C_and_C%2B%2B
24. C++23: compatibility with C
    https://www.sandordargo.com/blog/2023/08/23/cpp­23-c-compatibility
25. Can C++ Run C Code? Understanding Language Compatibility
    https://www.codewithc.com/can-c-run-c-code-understanding-language-compatibility/
26. C3: Comparisons With Other Languages
    https://c3-lang.org/faq/compare-languages/
27. C3 Programming Language Gains Traction as Modern C Alternative
    https://biggo.com/news/202504040125_C3_Pro­gramming_Language_Alterna­tive_to_C
28. The case against a C alternative
    https://c3.handmade.networ­k/blog/p/8486-the_case_against_a_c_alternative
29. C (programming language) Alternatives
    https://alternativeto.net/software/c-programming-language-/
30. Seriál Programovací jazyk Go
    https://www.root.cz/seria­ly/programovaci-jazyk-go/
31. Is C3 the Underdog That Will Overtake Zig and Odin?
    https://bitshifters.cc/2025/05/22/c3-c-tradition.html
32. „Hello, World!“ program
    https://en.wikipedia.org/wi­ki/%22Hello%2C_World!%22_pro­gram
33. The C Programming Language
    https://en.wikipedia.org/wi­ki/The_C_Programming_Langu­age
34. Kontejner (abstraktní datový typ)
    https://cs.wikipedia.org/wi­ki/Kontejner_(abstraktn%C3%AD_da­tov%C3%BD_typ)
35. Are arrays not considered containers because they are not based off of a class?
    https://stackoverflow.com/qu­estions/37710975/are-arrays-not-considered-containers-because-they-are-not-based-off-of-a-class
36. Array declaration (C, C++)
    https://en.cppreference.com/w/cpp/lan­guage/array.html
37. Understanding the Apple ‘goto fail;’ vulnerability
    https://www.blackduck.com/blog/un­derstanding-apple-goto-fail-vulnerability-2.html
38. Branch (computer science)
    https://en.wikipedia.org/wi­ki/Branch_(computer_scien­ce)
39. Conditional (computer programming)
    https://en.wikipedia.org/wi­ki/Conditional_(computer_pro­gramming)
40. Dangling else
    https://en.wikipedia.org/wi­ki/Dangling_else
41. Switch statement
    https://en.wikipedia.org/wi­ki/Switch_statement
42. Compiler correctness
    https://en.wikipedia.org/wi­ki/Compiler_correctness
43. Anonymous function
    https://en.wikipedia.org/wi­ki/Anonymous_function
44. Closure (computer programming)
    https://en.wikipedia.org/wi­ki/Closure_(computer_program­ming)
45. How to implement closures in C
    https://hokstad.com/how-to-implement-closures
46. An Overview of Macros in Rust
    http://words.steveklabnik.com/an-overview-of-macros-in-rust
47. A Practical Intro to Macros in Rust 1.0
    https://danielkeep.github.io/practical-intro-to-macros.html
48. The Rust Programming Language: macros
    https://doc.rust-lang.org/beta/book/macros.html
49. Rust by example: 15 macro_rules!
    http://rustbyexample.com/macros.html