Wasze języki programowania

Zapewne grupa torgowych koderów spotkała się z tworzeniem własnego języka programowania.
I na pewno, jakis ich % go stworzył. Tak więc mam pytanko, czy udało wam się kiedys stworzyc język programowania.
Jesli tak, to się pochwalcie, co wam szkodzi.


Ja może zaczne.
Mój język programowania zwie się Topaz (nazwa kodowa, musze znalezć jakis zenski odpowiednik).
Powstał 3-4 dni temu. Jest to język skryptowy (nie chciałem się jebac asemblerem), oparty na bardzo lekkim VM.
Ma obsługę bibliotek standardowych C i WinApi( znaczy w trakcie budowy jest stdlib Topaza). Jako że jest bardzo fajny, można w nim napisać wirusy, które napisane w innym jezyku, zostałyby wykryte.
Jako że jestem samoukiem, po napisaniu języka odkryłem że trzeba tworzyć jakies drzewa AST (wtf is that?). U mnie translator tego nie posiada.
Język będzie domenowo-ogólno użytkowy. Paradygmaty:
-Metaprogramowanie
-Proceduralny
-Imperatywny
Jezyk jest pelny w sensie maszyny Turinga.

Troche kodu:

Kod PHP:

---

#import main.tpz proc main(1); array tab[10000];int $cc; $cc="%i "; main.arg0 = 0; while main.arg0 != 9999 tab[main.arg0] = main.arg0; printf($cc,tab[main.arg0]); main.arg0=eval(main.arg0+1); endwhile printf($cc,tab[56]); end

---

tłumaczony na:

Kod:

---


NEW
NEW
NEW
NEW
MOV $14 1
MOV $16 0
MOV $15 $14
MOV $17 $16
PUSH 0
GOTO ::main
POPA
EXT
::MsgBox
NEW
POP1
MOV $18 $0
NEW
POP1
MOV $19 $0
PUSH 0
PUSH $19
PUSH $18
PUSH 0

CALL user32  MessageBoxA
RET
::puts
NEW
POP1
MOV $1A $0
PUSH $1A

CALL clib  puts
RET
::printf
NEW
POP1
MOV $1B $0
PUSH $1B

CALL clib  printf
RET
::system
NEW
POP1
MOV $1C $0
PUSH $1C

CALL clib  system
RET
::fopen
NEW
POP1
MOV $1D $0
NEW
POP1
MOV $1E $0
PUSH $1E
PUSH $1D

CALL clib  fopen
RET
::getc
NEW
POP1
MOV $1F $0
PUSH $1F

CALL clib  fgetc
MOV $0 $0
RET
::fgetc
NEW
POP1
MOV $20 $0
PUSH $20

CALL clib  fgetc
MOV $0 $0
RET
::fscanf
NEW
POP1
MOV $21 $0
NEW
POP1
MOV $22 $0
NEW
POP1
MOV $23 $0
NEW
STR "%s"
MOV $24 $0
PUSH $23
PUSH $22
PUSH $21

CALL clib  fscanf
RET
::ShowWindow
NEW
POP1
MOV $25 $0
PUSH $25

CALL stdlib  showwindow
RET
::comparestr
NEW
POP1
MOV $26 $0
NEW
POP1
MOV $27 $0
PUSH $27
PUSH $26

CALL stdlib  comparestr
CMP $13 $0==1
 ::000CE9B9
MOV $0 =1
MOV $0 $14
RET
::000CE9B9
CMP $13 $0==0
::000CE9B9 ::0009E1C0
MOV $0 =0
MOV $0 $16
RET
::0009E1C0
RET
::comparetext
NEW
POP1
MOV $28 $0
NEW
POP1
MOV $29 $0
PUSH $29
PUSH $28

CALL stdlib  comparetext
CMP $13 $0==1
::0009E1C0 ::00041166
MOV $0 =1
MOV $0 $14
RET
::00041166
CMP $13 $0==0
::00041166 ::000C2F79
MOV $0 =0
MOV $0 $16
RET
::000C2F79
RET
::concat
NEW
POP1
MOV $2A $0
NEW
POP1
MOV $2B $0
PUSH $2B
PUSH $2A

CALL stdlib  concat
RET
::delete
NEW
POP1
MOV $2C $0
NEW
POP1
MOV $2D $0
NEW
POP1
MOV $2E $0
PUSH $2E
PUSH $2D
PUSH $2C

CALL stdlib  delete
RET
::pos
NEW
POP1
MOV $2F $0
NEW
POP1
MOV $30 $0
PUSH $30
PUSH $2F

CALL stdlib  pos
RET
::main
NEW
POP1
MOV $31 $0
NEW
NEW
STR "%i "
MOV $2742 $0
MOV $31 0
::000A2389
MOV $32+$31 $31
PUSH $2742
PUSH $32+$31
GOTO ::printf
POPA
EVAL $31+1
MOV $31 $0
CMP $31 9999
JMNE ::000A2389
PUSH $2742
PUSH $32+56
GOTO ::printf
POPA
RET

---

Jedyny problem z jakim sie spotykam, to brak pomyslu na dodanie klas i obiektów :(


Teraz wasza kolej na chwalenie.

Wątpię czy na torgu ktoś się w takie coś bawił.

Drzewa AST uzywane sa do rozbijania polecen (statementow) na skladowe, ktore potem sa analizowane. Drzewo buduje zazwyczaj jakis parser, ktory poslugujac sie liniowa, zpriorytetyzowana lista tokenow "wie", w ktory miejscu podzielic statement. O ile w przypadku 2 operandow nie musisz miec drzewa, o tyle w 2+ przypadkach juz musisz miec. Jest to cos podobnego do odwrotnej notacji polskiej.

Odnosnie topicu, domyslam sie ze te polecenia sa sprytnie "zamieniane" z kodem pseudo-asm? Wyglada cool :)

Cytuj:

---

O ile w przypadku 2 operandow nie musisz miec drzewa, o tyle w 2+ przypadkach juz musisz miec. Jest to cos podobnego do odwrotnej notacji polskiej.

Odnosnie topicu, domyslam sie ze te polecenia sa sprytnie "zamieniane" z kodem pseudo-asm? Wyglada cool :)

---

A własnie radze sobie przez funkcje eval() która jest w stanie policzyc wszystko, łącznie z pozycją Boeninga 777, które może mieć 100 operandow. Wykorzystuje ONP.

I miło że się podoba. Prędkosc wykonania kodu z 1 posta, bez wyswietlania wynosi ok. 1s, z wyswietlaniem więcej.
Jak sie doda. $x="color b"; system($x) to przypomina matrix ;)

Mialem akurat pod reką, polecam do poczytania: http://www-cs-students.stanford.edu/...html#languages

"..except for Prolog. That's still to weird."
xD
Dzięki, ciekawa lekturka ;)

Nie pisałem nigdy nowego ponieważ tego nie potrzebowałem, natomiast mam spore doświadczenie z parsowaniem kodu i tłumaczenia go na inny język , sporo z analizą statyczną ( Np, na moim githubie można znaleźć niedokończony projekt emulujący zapytania SQL w PHP, a także tłumacz OBScript na Papyrus [ do tłumaczenia skryptów z gry Oblivion do Skyrima ] ). Podejrzewam, że napisanie czegoś takiego nie stanowiłoby problemu ;)
Co Cię skłoniło do takiego projektu?

nas na studiach teraz uczą języka Loglan, mój profesor sobie go wymyślił 40 lat temu z kolegami i tylko oni uzywaja ;D

Zawsze jest fajnie miec swój język ;)
666 post.
Gogo 6666

Welcome to Topaz ;D

Kurcze :/

To może ktos zasugeruje inna nazwe?

@EDIT:

Udało mi się dodac klasy. Póki co bez hermetyzacji i dziedziczenia:

Kod:

---

class Klasa
_self.init(0);

int _self.x;
int _self.y;

proc _self.Metoda(0);
_self.y="Hello form _self"
puts(_self.y);
end;

proc _self.init(0)


endclass
[...kod...]

object Obiekt:Klasa
object Obiekt2:Klasa

Obiekt.x=100;
Obiekt.Metoda();
Obiekt2.x=100;
Obiekt2.Metoda(0);

---

@EDIT2:
Dodałem taki zabieg, że np. Zmienna Obiekt zwraca jakas wartosc, jesli w Klasie jest uzyte int _self

To pozwala na stworzenie nieskonczonej ilosci typów danych bazujacych na Klasach (tak jak w innych jezykach, gdzie np. zmienna int jest obiektem)


@EDIT3:
Jak wyzej wspomniałem, udało mi się uzyskać taki efekt:

Kod:

---

#import main.tpz

class string;
_self.init(0);


proc _self.puts(0);
puts(_self);

end

proc _self.init(0)
int _self;
_self=" ";

endclass;

proc main(0); 
       
object $i:string;
$i="Jestem obiektem! ;)";
$i.puts(0);
puts($i);
pause(0);

---

Wyjscie:
Jestem obiektem! ;)
Jestem obiektem! ;)

Co wy na to? @TheSnake ; @szulak ;

Lord Compi

Wyglada fajnie, ale mam takie dziwne przeczucie, że za niedługo napotkasz pewien "problem", w ktorym bedziesz musial wszystko przepisać. Ponadto, wg mnie, syntax jest taki... dziwny. Taki mix pythona-php. Anyway, możesz mi podesłać swój skype, w razie W i wymiany doświadczeń.

EDIT:
Napisalem Ci na szybko przyklad, jak mozesz zaimplementowac prosty kontainer. To tylko mock up, ale mysle ze sobie poradzisz.

Kod:

---

#include <string>

class Value
{
        std::string                m_name;
public:
        Value(const std::string& name) : m_name(name) { }
};

template <typename T = void>
class ValueType : public Value
{
        T        m_data;
public:
        ValueType(const std::string& name, const T& t) :
                Value(name), m_data(t) { }
};

class Table
{
        Value*        m_values;

public:
        bool insert(const Value& value) {
                if (m_values) {
                        //todo
                }
                return true;
        }

};


int main()
{
        Table t;
        t.insert(ValueType<int>("jakis_int", 10));
        t.insert(ValueType<float>("jakis_float", 25.6f));
        t.insert(ValueType<char>("jakis_char", 'x'));


    return 0;
}

---

@szulak ; Nie mam skajpów ani nic z tych rzeczy. Tylko forum albo irc.
Kontajnery moge dodac z poziomu języka. Zrobie to po dodaniu hermetyzacji i dziedziczenia.
Mysle nad nazwami takimi jak:
LSD( Language for Scriptable Domains), Pool (Paradigmatic object oriented language) i Koral

Podaje tutaj specyfikacje języka na dzień dzisiejszy.
Jesli ktos by się nudził, to zawsze może pomóc przy rozbudowie main.lib

Kod:

---

Koral - Specyfikacja języka oraz opis


        Koral to język skryptowy tłumaczony do IL (Kodu posredniego), wykonywanego przez maszyne wirtualną KoralVM.
Jest to język wysokiego poziomu, kompatybilny z WinAPI oraz C stdlib. Język jest kompletny w sensie Turinga, pozwala także
na budowanie oddzielnych plików wykonywalnych. Jego zalętą jest prostota.
        Koral powstał 25 marca 2014, a 2 tygodnie później miał już rozwinięte wszystkie funkcje. Składnia języka jest podobna do
Pythona, PHP oraz Ruby. Paradygmaty jakie spełnia:
-Obiektowy
-Imperatywny
-Funkcyjny
-Strukturalny

Głównym typem zmiennych jest 32bitowy DWORD (zapis na 4 bajtach), który uniwersalnym typem do zapisu danych.
Wspierane na dzien dzisiejszy (5.04.14r) typy danych to String,Plik,Char,Byte,Array. Wszystkie są przedstawione w 4 bajtowym interfejsie.
Jedyna konwersja zmiennych jaka zachodzi zamiana zmiennej int na 4 bajtowy wskaznik podczas przypisywania zmiennej typu string.

Przykład:
int $foo;
$foo="bar"

Do zmiennej $foo (dolar jest tylko ozdobą, dozwolone jest nazywanie zmiennych według uznania) trafia adres zaalokowanego łańcucha "bar".
Oczywiscie taką zmienna mozna bezproblemu przekazać do zewnętrznej funkcji z obcej biblioteki lub wykorzystywać wew. Korala.
Wszelkiego typu operacje matematyczne wykonujemy poprzez Eval(), który jest interfejsem maszyny RPN (Reverse Polish Notation).
Zwracany jest wynik w formacie DWORD.

Każda operacja przechowuje swój wynik w zmiennej $0 (odpowiednik akumulatora). Aby przechować wynik, należy zapisać go innej zmiennej przed opuszczeniem
danego bloku kodu.

Pierwszy program

Kod:

#import main.lib

proc main;
int $x;
$x="Hello world!";
puts($x);
pause();

return 0


Po uruchomieniu zobaczymy okienko z napisem Hello World.

Zmienne

Zmienna to rodzaj bufora (zbiornika) na dane. Pierwszą rzeczą jaką musimy zrobić, to nazwanie jej.
Kod:

int foo;

lub:

int $foo;

W jednej linii możemy jednoczesnie utworzyć jedną zmienną.
Znak dolara jest tylko dekoracją, możemy pozwolić sobie na pomijanie go.
Po utworzeniu i nazwaniu zmiennej, możemy zapisywać w niej dane.

$foo="bar";
Do zmiennej $foo zapisalismy tekst "bar".

$foo=100;
Do zmiennej $foo zapisalismy liczbę 100

$foo=funkcja(argumenty);
Do zmiennej $foo zapisalismy wynik funkcji funkcja o argumentach argumenty

$foo=eval($foo+10);
Do zmiennej $foo zapisalismy wynik operacji matematycznej $foo+10


Funkcje

Funkcja to blok kodu, rozpoczęty słowem proc nazwafunkcji(liczba argumentów); a zakonczony jest słowem end lub return (jesli zwraca wartosc).
Jesli do kodu dołączasz standardową biblioteke (#import main.lib), musisz zdefiniować punkt wejscia. Z góry założone jest że będzie to funkcja main;

#import main.lib
proc main;

end;

O to przykład najprostrzego programu. Jesli nasz program nie bedzie posiadał funkcji main, ujrzymy błąd:
Code block called '::main' not found!

Każda funkcja może posiadać od 0 do n argumentów. Jesli jest to funkcja zewnętrzna (z poza Korala), to maksymalna liczba argumentów to 11.
Przykład:

proc funkcja(2);

W ten sposób jesli wywołamy funkcje w ten sposób funkcja(100,200); to pod zmiennymi
funkcja.arg0 będzie 100
funkcja.arg1 będzie 200

Argumenty nazywane są w ten sposób nazwa_funkcji.argN gdzie N to indeks argumentu. Iteracja zaczyna się od zera, więc jesli jako liczbę argumentów podamy 1,
zostanie utworzony tylko jeden argument pod indeksem 0.

Przykład:

#import main.lib

proc dodaj(2);
        int $zmienna;
        $zmienna=eval(dodaj.arg0+dodaj.arg1);
        return $zmienna

proc main;
        int $wynik;
        $wynik=dodaj(2,2);
        end;

Jako argument fukcji może przejsc tylko zmienna lub liczba całkowita. Łancuchy znaków lub funkcje wywołają błąd:

Przykład:

#import main.lib
proc main;
printf("TEKST");
end;

Ujrzymy błąd:
Non-number value on stack! : "TEKST"

Wbudowaną funkcją jest eval()
Jako argument przyjmuje wyrażenie matematyczne. Oczywiscie tylko na zmiennych lub liczbach całkowitych.
Aby funkcja zwróciła wartosc, kończymy ją słowem return N; gdzie N to zmienna lub liczba całkowita.

Tablice

Tablice to zbiór zmiennych pod tą samą nazwą, okreslony długoscią.
array $i[1000];

Tworzymy tutaj tablice o ilosci indeksów 0..1000, czyli mamy dokładnie 1001 pozycji (iteracje zaczynamy od 0).
Aby odwołać się do elementu tablicy, używamy nazwy oraz indeksu w nawiasach kwadratowych [].
Jako indeks może posłużyć liczba całkowita lub zmienna.

Przykład:

$i[100]=0;

lub:

$zmienna=100;
$i[$zmienna]=0;

Oba sposoby przypiszą pod 101 element tablicy wartosc 0
Elementy tablicy to standardowe zmienne.

Warunki

Koral dopuszcza taką składnie IF'a
Zapis:
if wartosc1 znak wartosc2
        blok kodu
endif

wartosc1 oraz wartosc2 to zmienna lub liczba całkowita.
Natomiast znak to jeden lub dwa symoble:
== - sprawdź czy obie wartosci są równe
!=  - sprawdź czy obie wartosci są nierówne
>= - sprawdź czy wartosc1 jest większa lub równa wartosc2
<= - sprawdź czy wartosc1 jest mniejsza lub równa wartosc2
> - sprawdź czy wartosc1 jest większa od wartosc2
< - sprawdź czy wartosc1 jest mniejsza od wartosc2

Jesli warunek jest prawdą (warunek to wartosc1 znak wartosc2), wykona się blok kodu poniżej, jesli wynikiem porównania jest fałsz, kod w bloku zostanie pominięty.

Przykład:

if $x<100
jakasfunkcja();
endif

Iteracje (pętle)

Zapis:
until warunek;
        blok kodu
endloop;

Warunek jest dokładnie taki sam jak w IF'ie. Jesli warunek zwróci prawdę, program opusci pętle.
Przykład:

$x="%i ";
$i=0;

until $i==1000;
printf($x,$i);
$i=eval($i+1);
endloop;

Klasy

Klasa jest częściową lub całkowitą definicją dla obiektów. Definicja obejmuje dopuszczalny stan obiektów oraz ich zachowania. Obiekt, który został stworzony na podstawie danej klasy nazywany jest jej instancją. Klasy mogą być typami języka programowania - przykładowo, instancja klasy Owoc będzie mieć typ Owoc. Klasy posiadają zarówno interfejs, jak i strukturę. Interfejs opisuje, jak komunikować się z jej instancjami za pośrednictwem metod, zaś struktura definiuje sposób mapowania stanu obiektu na elementarne atrybuty.

Zapis:

class NazwaKlasy;
        kod wykonany przed konstruktorem
        _self.init();

        proc _self.NazwaMetody;
        blok kodu
        end;
       
        proc _self.Nazwa2Metody;
        blok kodu
        end;

        proc _self.init;
        kod wykonywany podczas tworzenia obiektu
        tutaj tworzymy pola obiektu, czyli zmienne w obrębie klasy

endclass;

Metoda to funkcja osadzona w klasie, która może zostać wywołana przez obiekt.
_self oznacza tutaj instancje. Nazwy metod mają nazwę _self.Nazwa.
To oznacza ich przynależnosc i wyróżnia od innych funkcji.


Konstruktor (_self.init()) jest wykonywany podczas tworzenia instancji.
Pola, to zmienne które opisują własciwosci obiektu.
Koral przewiduje nazwy o zapisie int _self.Nazwa;
Dopuszczalne jest tworzenie tablic oraz innych typów zmiennych, pod warunkiem podanym wyżej.

Tworzenie instancji (obiektów).
Każdy obiekt może przechować domyslną wartosc, co pozwala na traktowanie obiektów jako zwykle zmienne.

object nazwaobiektu:nazwaklasy

Przykład:

class Klasa;
        _self.init();
        proc wypisz;
        puts(_self);
        end;
       
        proc _self.init;
        int _self.x;
        int _self.y;
endclass;

Reszta kodu. Klasy definiujemy poza funkcjami

proc main;

object Obiekt:Klasa;
Obiekt="Jestem obiektem";
Obiekt.wypisz();
Obiekt.x=100;
Obiekt.y=200;
Obiekt.x=eval(Obiekt.x+Obiekt.y);

end;



Po wykonaniu powyższego kodu wyswietli sie napis Jestem obiektem
Do pola x instancji Obiekt zostanie przypisana wartosc 300.

Dziedziczenie

Koral dopuszcza dziedziczenie klas.
Oznacza to, że jedna klasa otrzymuje dodatkowo metody i pola z innej klasy.

Zapis:

class Rodzic
        _self.init();
        proc _self.wyswietl;
        puts(_self);
        end;
        proc _self.init;
       
        int _self.Zmienna
endclass;

//Jakis kod

class Dziecko
        _self.init();
        proc _self.JakasMetoda;
        kod
        end;
        inherit Rodzic;
                int _self.Zmienna2;
                wywołanie dziedziczenia zastępuje konstruktor.
                tutaj mozemy opisac pola, ponieważ ten blok zostanie wykonany jako konstruktor
endclass;

//Jakis kod

object Obiekt:Dziecko;
Obiekt="Dziedzicze od Rodzica";
Obiekt.wyswietl();

Klasa Dziecko odziedziczy wszystkie pola i metody z klasy Rodzic.
Posluzy do tego słowo inherit NazwaKlasy; użyte zamiast konstruktora klasy Dziecko.
Błędem jest dodanie definicji konstruktora w klasie, która dziedziczy. Wywoła to nieskończoną pętle między konstruktorami, przez co reszta kodu nie zostanie wywołana.

Wywoływanie funkcji zewnętrznych

Do tego posłuży nam słowo external.

Zapis:

external nazwabiblioteki nazwaprocedury(argumenty);

Przykład:

proc MsgBox(2);

external user32 MessageBoxA(0,MsgBox.arg0,MsgBox.arg1,0);
end;

---

Jako załącznik dorzucam sformatowaną specyfikacje
Załącznik 310631

Napisz coś więcej o VM i może wrzuć jakieś binarki już jak możesz :)

- Imperatywny
- Funkcyjny

No to jaki w końcu?

Pisze z fona.
Alex, chodzi mi o rachunek lambda. Nie jest w specyfikacji bo jeszcze nad nim pracuje.
Binarki wrzuce jutro lub pojutrze
@edit: Poza tym te dwa paradygmaty sie nie wykluczaja jesli uzyje funkcyjnego
w mniejszym stopniu @Alex Fortune ;