Temat: Wasze języki programowania

#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

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

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);

#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);

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;