Uclang - programming language

19.6.2015 17:23 | Přečteno: 1258× | Vývoj software |

V tomto zápisku vám představím skriptovací jazyk (včetně jeho interpretu), který byl důvodem pro vytvoření generátoru překladačů yapgen. Jazyk se jmenuje uclang a popisuji jej jako dynamicky typovaný, objektově orientovaný, vysokoúrovňový, programovací jazyk.

Tento zápisek obsahuje jen ukázky některých základních vlastností skriptovacího jazyka. Nechci se v něm podrobně rozepisovat o implementačních detailech a motivaci k jeho vytvoření. Zmíním pouze v odrážkách několik bodů týkajících se motivace a zacílení jazyka:

• Syntaxe odvozená od C/C++.
• Kontrola nad procesem a jeho vlákny.
• Objektově orientované programování, dědičnost a výjimky.
• Lightweight interpret jazyka, běžící na embedded zařízeních.
• Modulový systém, efektivní lepení existujících C/C++ knihoven.
• Integrace modulů do C/C++ ve formě knihoven.

Vlastnosti skriptovacího jazyka

Zde uvádím výčet několika základních vlastností jazyka uclang, které jej charakterizují.

Syntaxe jazyka

Syntaxe jazyka uclang je odvozena od syntaxe jazyka C/C++ s prvky vypůjčenými z jazyka Java. Prvky syntaxe převzaté z jazyka Java se týkají převážně dědičnosti a zápisů týkajících se dědičnosti.

Příklad zdrojového souboru

class Main
{
  static fact(num)
  {
    result = 1;
    while (num > 1) result *= num--;
    return result;
  }

  static public main(argv)
  {
    ("fact(10): %d\n" % fact(10)).print();
  }
}

Výstup skriptu:

fact(10): 3628800

Objektově orientovaný přístup

Jazyk je silně objektově orientovaný. Všechny hodnoty v jazyce jsou reprezentovány objekty a je s nimi jako s objekty zacházeno.

Příklad objektového přístupu

class Main
{
  static public main(argv)
  {
    "String is object\n".print();

    num = new Float(9);
    ("9.0.sqrt(): %f\n" % 9.0.sqrt()).print();
    ("num.sqrt(): %f\n" % num.sqrt()).print();
  }
}

Výstup skriptu:

String is object
9.0.sqrt(): 3.000000
num.sqrt(): 3.000000

Jazyk neobsahuje globální funkce, všechny operace realizované skriptem jsou prováděny metodami jednotlivých objektů. Je definováno několik globálních operací, které není možné realizovat prostřednictvím metod objektů, mezi tyto patří například: new, free a type, které slouží k vytvoření nového objektu, okamžitému uvolnění reference na objekt, a získání identifikace typu objektu.

Příklad použití operací type a free

class Main
{
  static public main(argv)
  {
    integer = new Integer("0xff");
    ("integer: %d\n" % integer).print();

    variable = 10;
    ("variable: %s\n" % variable.to_string()).print();

    free variable;
    ("variable: %s\n" % variable.to_string()).print();

    "types:".print();
    (" %s" % (type 1000000).to_string()).print();
    (" %s" % (type 10000.0).to_string()).print();
    (" %s" % (type "Hello").to_string()).print();
    (" %s" % (type [1,2,3]).to_string()).print();
    "\n".print();
  }
}

Výstup skriptu:

integer: 255
variable: 10
variable: <blank>
types: Integer Float String Array

Popis tříd je oddělen od jejich instancí. Při běhu programu zůstává popis tříd neměnný, obdobně jako v jazyce C/C++. Při překladu zdrojového souboru a následném generování byte kódu proběhne statická analýza založená na výše uvedené vlastnosti jazyka.

Příklad statické kontroly

class RightName
{
  public RightName() {}
}

class Main
{
  static public main(argv)
  {
    right_object = new RightName(); // - OK -
    wrong_object = new WrongName(); // - ERROR -
  }
}

Chybový výstup (při překladu skriptu):

 ---------------------------------------- 
1. ERROR: in file: "_modules/docu.ucl" on line: 11
    wrong_object = new WrongName(); // - ERROR -

Class name WrongName cannot be resolved
 ---------------------------------------- 

Dědičnost v jazyce uclang je implementována pomocí klíčového slova extends v rámci deklarace třídy. Klíčovým slovem abstract je možné definovat třídy reprezentující rozhraní s abstraktními metodami. Metody je možné proti přepsání (overload) chránit klíčovým slovem final.

Příklad dědičnosti a rozhraní

class Parent {}
class Child extends Parent {}

abstract class StorageBase
{
  abstract public size();
  abstract public used();
  final public dummy() {}
}

class StorageNull extends StorageBase
{
  public size() { return 0; }
  public used() { return 0; }
  public dummy() {} // - ERROR -
}

class Main
{
  static public main(argv) {}
}

Chybový výstup (při překladu skriptu):

 ---------------------------------------- 
1. ERROR: in file: "_modules/docu.ucl" on line: 15
  public dummy() {} // - ERROR -
         ^
Class StorageNull cannot override final method StorageBase.dummy#0
 ---------------------------------------- 

Dynamicky typovaný jazyk

Jazyk provádí dynamickou typovou kontrolu. Interpret jazyka neprovádí žádné implicitní konverze dat, např.: mezi řetězci, číselnými typy apod. V případě, že je metodě předán parametr, který neumí zpracovat je vyhozena výjimka informující o chybě.

Příklad silné typové kontroly

class Main
{
  static public main(argv)
  {
    number = 0;
    string = "Hello";

    number += 10;   // - OK -
    number += "10"; // - ERROR -

    string += " world!"; // - OK -
    string += 10;        // - ERROR -
  }
}

Výstup skriptu:

 ---------------------------------------- 
Exception: ERROR: in file: "_modules/docu.ucl" on line: 9
    number += "10"; // - ERROR -

Method Integer.operator_binary_plus_equal#1 is not defined for parameter/s: (String)
 ---------------------------------------- 

Vyhazování výjimek při výskytu chyby

Jak je pravděpodobně zřejmé z již uvedených příkladů, chybové operace v jazyce uclang vyhazují výjimky. Vyhazované výjimky obsahují popis chyby, která nastala a informace umožňující lokalizaci zdroje této chyby.

Příklad vyhazování výjimek

class Main
{
  static public main(argv)
  {
    str = "Number: %d,%d,%d" % [1,2,3,4];
  }
}

Výstup skriptu:

 ---------------------------------------- 
Exception: ERROR: in file: "_modules/docu.ucl" on line: 5
    str = "Number: %d,%d,%d" % [1,2,3,4];

Not all arguments converted during string formatting
 ---------------------------------------- 

Vícevláknové programování

Interpret jazyka umožňuje běh skriptu ve více vláknech, jejichž synchronizaci musí zajistit programátor pomocí standardních prostředků. Interpret jazyka uclang neobsahuje žádný GIL (Global Interpreter Lock). Nové vlákno se spouští zavoláním statické funkce označené klíčovým slovem parallel.

Příklad vícevláknového výpočtu

static public parallel do_work(a_count)
{
  result = 0;
  idx = 0;
  while (idx < a_count)
  {
    result += idx++;
  }

  return result;
}

static public main(argv)
{
  thread = do_work(100);

  ...

  result = thread.join();
  ("result: %d\n" % result).print();
}

Výstup skriptu:

result: 4950

Modulový systém jazyka

Modulový systém umožňuje vytvářet moduly v jazyce C/C++, reprezentované dynamickými knihovnami operačního systému. Vestavěné typy jazyka jsou implementovány v rámci modulu base, který je importován při každém spuštění interpreta. Práce s vestavěnými datovými typy (v rámci interpretu) je shodná s prací s jinými datovými typy implementovanými v C/C++ modulech.

Příklad použití modulu

import containers;

class Main
{
  static public main(argv)
  {
    dict = new Dict();

    dict[1] = "Number";
    dict["Hello"] = "String";
    dict[[1,2,3,4]] = "Array";
    dict[new Dict([1,2,3,4])] = "Dict";

    ("%s\n" % dict[1]).print();
    ("%s\n" % dict["Hello"]).print();
    ("%s\n" % dict[[1,2,3,4]]).print();
    ("%s\n" % dict[new Dict([1,2,3,4])]).print();
  }
}

Výstup skriptu:

Number
String
Array
Dict

Uspořádání objektů

Všechny objekty tříd implementujících metodu compare#1 porovnávající objekt s objektem stejného typu, jsou porovnatelné se všemi definovanými objekty. Implementace datových typů Tree, Set a Dict využívají red-black strom pro uložení jednotlivých prvků, respektive klíčů.

Příklad použití objektu uživatelské třídy jako klíče

import containers;

class Key
{
  m_id;

  public Key(a_id) { m_id = a_id; }

  public compare(a_second)
  {
    return m_id.compare(a_second.m_id);
  }
  
  public to_string()
  {
    return "Key(%d)" % m_id;
  }
}

class Main
{
  static public main(argv)
  {
    dict = new Dict();
    
    idx = 0;
    do {
      dict[new Key(idx)] = "*"*idx;
    } while(++idx < 7);

    ("dict: %s\n" % dict.to_string()).print();
  }
}

Výstup skriptu:

dict: [Key(0):,Key(1):*,Key(2):**,Key(3):***,Key(4):****,Key(5):*****,Key(6):******]

Lightweight interpret

Interpret jazyka byl zamýšlen pro běh na embedded zařízeních s operačním systémem linux či podobným. Interpret samotný a jeho základní moduly nejsou závislé na žádných knihovnách třetích stran. Interpret a jeho základní moduly jsou multiplatformní, doposud testováno na platformách: linux (x86, arm, mpc5200), android (arm), raspberry pi (arm) a win (xp,7).

Další informace

Jazyk a jeho interpret jsem ze začátku tvořil ze zvědavosti, ale později se ukázal i jako vhodný nástroj pro lepení C/C++ knihoven a při řešení některých úloh. Pokud by vám to nevadilo, občas by jsem se tu upsal o nějaké jeho zajímavé vlastnosti, případně o problému, který jsem musel při implementaci řešit, apod.

Odkazy na zdrojové soubory interpretu jazyka uclang.

Demonstrace použití některých modulů prostřednictvím samostatných skriptů. Embryonální fáze dokumentace. Dokumentace některých modulů prostřednictvím skriptů demonstrujících jejich vlastnosti.

Překladač, který je součástí interpretu jazyka uclang byl vygenerován programem yapgen. Implementace interpretu jazyka uclang byla realizována nad kontejnery generovanými programem cont.

       

Komentáře

[Miriam]

Pěkný zápisek, překvapuje mě, že ho publikuješ na téhle žumpě. Na rootu by ti to vzali s pár úpravama jako článek a dostal bys odměnu a hlavně lepší publikum.

[komunista]

ty si zumpa...

[Miriam]

+1

[kozzi]

Tak je to takove horsi D a s mensim vykonem. Kazdopadnej zajimavej projekt.

[Bedňa]

Mne sa to celkom páči, ale U++ to má predsa viac dotiahnuté. Ale kvitujem každú snahu postaviť niečo nad C++ s dobrou kontrolou nad najčastejšími chybami.

[unicode]

U++? To je snad vtip

[Bedňa]

Sorry nechápem.

[vlastikroot]

Proc vlastne pouzivat U++ kdyz mame Qt?

[Bedňa]

Tak QT aplikácie sa dnes dajú písať v Pythone, JavaScripte a neviem čom, zato U++ je orientované na programátorov C++ ktorí chcú niečo naviac.

[vlastikroot]

Qt/QML stejne stavi na silny integraci s C++, hlavne teda na Meta Object Systemu.

[Bedňa]

U++ zas stavá na kontajneroch a RAD, niečo ako Java v C++, alebo tak niečo :)

[vlastikroot]

Zkousel jsi nekdy QtCreator? To je teprv RAD.

[kralyk z abclinuxu]

zato U++ je orientované na programátorov C++ ktorí chcú niečo naviac

Nevim o tom, že by U++ poskytovalo něco navíc. IMHO všechno, co v U++ prezentují jako velkou revoluci, je v C++ bežná praxe (RAII, apod.).

[kralyk z abclinuxu]

Já mu říkám, že U++ není nic moc už asi dva roky ale on to furt ne a ne vstřebat

[Bedňa]

To nieje pravda Inak tento rok vyšila po odmlke nová verzia.

[kralyk z abclinuxu]

Je ocenitelný, že se autoři snaží, ale 1) nevidím nikde žádné balíčky - v Archu nic není, dokonce ani v AURu; 2) vypadá to, že používají GTK jako backend. To už můžu použít rovnou GTK nebo GTKmm a nemusím se zabývat s U++...

[Bedňa]

Nemám Arch, ale toto nefunguje? TheIde je Idečko a upp je framework, je tam verzia aj bez GTK.

Mrkni na príklady, vyber si niektorý z nich hoď do vyhľadávača QT názov aplikácie, alebo GTK názov aplikácie a porovnaj si kód.

[vlastikroot]

Jo, Qt ma kratsi a hezci kod GTK delsi a hnusnejsi takze tak neco mezi.

[kralyk z abclinuxu]

GTK má hnusnej kód, protože OOP v C. Nicméně to, že GTK je v C umožňuje imho mnohem snažší tvorbu bindings. Napsat binding pro Qt, které je v C++/MOC, je imho o dost náročnější. Například co se Rustu týče, GTK binding se rýsuje, Qt je v nedohlednu...

[kralyk z abclinuxu]

Nemám Arch, ale toto nefunguje? TheIde je Idečko a upp je framework, je tam verzia aj bez GTK.

Aha, dík, nenapadlo mě hledat upp...

Mrkni na príklady, vyber si niektorý z nich hoď do vyhľadávača QT názov aplikácie, alebo GTK názov aplikácie a porovnaj si kód.

Já na ty příklady koukal onehdá. Jako není to špatný, vypadá to relativně dobře (když jim odpustim to naprosto haluzný použití operátorů), ale není tam nic, co by mě fakt nějak zaujalo - to "Radical and innovative" tam úplně nevidim Memory management je v porovnání s Qt nebo C++11 IMHO méně vymakaný. Ale jak říkám, špatný to není a v zásadě je i obdivuhodný, že to někdo stále ještě píše (nevypadá to na moc lidí, co by za tim stáli).

Ale v konkurenci Qt, GTK, apod. to neobstojí, se obávám.

[Bedňa]

Môj pohľad: Kód je rýchlo čitateľný. Pre Vlastíka: ten kód býva spravidla kratší vďaka zápisu viď. link nižšie.

Keď porovnám QT/C++ z doby keď vzniklo U++ Tak to bolo rozhodne "Radical and innovative", hoci oni pod RAD mysleli Rapid Application Development

Pohľad autorov, stojí za prečítanie.

Ku QT sa radšej nebudem vyjadrovať to je na flame.

Ešte by som dopnil prístup k vyhýbaniu sa omylom, vrátane minimalizácie používania pointrov, ale to je vlastne v tom linku čo som dával.

[kralyk z abclinuxu]

Pohľad autorov, stojí za prečítanie.

Jo, to jsem čet. Vlastní kontejnery nemám rád ani u Qt ani u víceméně jakýhokoli jinýho projektu, zas někdo znovuvynalézá kolo. "Všechno někam patří" - tím mají na mysli, že všechno se narve na stack. "Kód vlastní widgety" - ditto.

Ta callback syntaxe se mi nelíbí hlavně pro to, že z toho kódu vůbec není jasné, jaká událost ten callback vyvolá.

Ešte by som dopnil prístup k vyhýbaniu sa omylom, vrátane minimalizácie používania pointrov, ale to je vlastne v tom linku čo som dával.

Jo, tím, že všechno narvou na stack, to je teda řešení...

[Bedňa]

Mne sa to páči a keby dali programátorom ukážky kódu v U++ a QT na výber pred začiatkom až si na niečo navyknú tak by U++ malo určite väčšiu komunitu.

U++ je proste o priečku vyššie nad C++ a stále je to C++ a môžeš si ďalej písať častí programov ako si bol zvyknutý, no môžeš využiť práve tie vychytávky ktoré sa tebe nepáčia

[kralyk z abclinuxu]

U++ je proste o priečku vyššie nad C++

To ani náhodou.

a stále je to C++ a môžeš si ďalej písať častí programov ako si bol zvyknutý, no môžeš využiť práve tie vychytávky ktoré sa tebe nepáčia

Nejde o to, že by se mi nepáčily vychytávky, jde o to, že tam IMHO žádný nejsou

[Bedňa]

Toto je čistý trolling

Inak pripomenul si mi nepriamo kolegu, keby ten Linux za niečo stál tak by ho väčšina ľudí používala. Odpovedal som mu že väčšina volila Fica a nestojí za nič.

Ja viem že si to priamo nenapísal, ale každý máme iný názor čo je fajn vďaka skúsenostiam, len mám pocit že by ľudia mali vedieť o niečom lepšom ako tu väčšina deklaruje

[kralyk z abclinuxu]

Ok, napiš jeden důvod, proč by U++ mělo být "o příčku výš" než C++11. Nebo jeden aspekt v čem je lepší než Qt (ačkoli to bych asi věděl i já - např. nevyžaduje MOC ).

[Bedňa]

Som to už spomínal, pre mňa prehľadný kód, ktorý nevyzerá ako Bouhošovi lívance. Eliminácie pointrov, kontajnery, TheIDE, nepoužívanie STL a citácia "Ultimate++ slibuje radikální zjednodušení kódu typických aplikací."

Tak schvále napíš tie Bohoušovi lívance na ten príklad čo som tu odkazoval, ten prvý kód v QT.

Citácia:

Nejdůležitějším je, že Ultimate++ nevyžaduje aby byly widgety alokované na haldě.

A tú subjektívnu prehľadnosť mi nezoberieš aj keď to všetko vyvrátiš

[kralyk z abclinuxu]

Proč jsou dobré kontejnery a nepoužití STL? Co máš proti STL?

Eliminácie pointrov

U++ "eliminuje pointery" tím, že všechno narve na stack. V C++11 máš samozřejmě možnost dávat věci na stack taky, ale krom toho máš k dispozici smart pointery, které se dají použít i v situacích, kde striktně stack-based alokace nestačí (sdílený přístup apod.). Qt dále kromě zmíněného nabízí thread-safe COW (QSharedData). Až bude mít U++ něco z toho, dej mi vědět...

Nejdůležitějším je, že Ultimate++ nevyžaduje aby byly widgety alokované na haldě.

Qt tohle taky nevyžaduje, widgety si můžeš dát na stack.

Nicméně v Qt je zvyk (ne nutnost) dávat widgety na heap, protože jejich lifetime se spravuje tím jejich QObject stromem, což osobně filosoficky vzato moc nemusim, nicméně v praxi tofunguje poměrně dobře.

Tak schvále napíš tie Bohoušovi lívance na ten príklad čo som tu odkazoval, ten prvý kód v QT.

Ok, tady to máš Napsal jsem to bez raw pointerů, aby se ti nedělaly pupínky

K tomu příkladu, který jsi odkázal, bych měl dvě otázky:

1) Co dělá ~date1 ? Netušim, co tam ten operátor ~ dělá.

2) Když mám kód nejakyWidget <<= THISBACK(nejakaFunkce); , jak poznám, kdy se ta funkce zavolá?

[Bedňa]

STL: Pretože je s tým viac práce a nezapadá to do konceptu kontajnerov.

krom toho máš k dispozici smart pointery Tak predsa možno nejaká obdoba v U++ bude, ale pokladalo sa to zlo :)

thread-safe COW: To je fajn, ale zas aj počet vývojárov je iný.

Ok, tady to máš Píšeš moc pekne, to sa zrazu aj QT dá pozerať Dík za snahu toto ma dosť presvedčilo na tvoju stranu.

Co dělá ~date1 ? Asi nejaký zbytočný destructor?

Když mám kód nejakyWidget <<= THISBACK(nejakaFunkce); Neviem či chápem otázku, ale podľa "events widget".

[Bedňa]

No a U++ je viac JavaTar

[vlastikroot]

Ja tam furt nevidim to pravidlo, proc by kod v Qt mel byt delsi. Spis naopak.

Spustim QtCreator. Nakreslim GUI v navrhari, kliknu pravym na tlacitko, dam jit na slot clicked, vyplnim co se stane v vygenerovanem kodu prehledym C++. Hotovo, zbyde mi main.cpp, .h s tridou, .cpp s funkci clicked, .ui s GUI a .pro pro qmake. Ty C++ zdrojaky dohromady stejne dlouhy jako ekvivalent s U++. Ale napsal jsem jen vnitrek ty funkce clicked.

[skunkOS]

Přesně tak. Někteří guru lidi se těm .ui orgiím vyhýbaj a celou setupUi(...) funkci si v zásadě píšou sami, ale to je věc spíš vkusu a kontroly. Osobně .ui soubory taky v tom designeru vytvářím a dost to z pohledu programátora zpřehledňuje celej program.

[vlastikroot]

Pekny, good job

[kralyk z abclinuxu]

Nechci se v něm podrobně rozepisovat o implementačních detailech a motivaci k jeho vytvoření.

To by mě ale zrovna docela zajímalo, zejména ta motivace

[RM]

Zajímavé, díky za příspěvěk.