Witam w kolejnym odcinku naszego brazylijskiego serialu. Dzisiaj zajmiemy sie zmiennym, stałymi i matematyką. Stałe i zmienne (zmienne to nic innego jak miejsce w pamięci o zmieniającej się od czasu do czasu zawartości) służą w programie do reprezentowania danych. Stała jest nazwą pewnej wartości, która w całym programie nie ulega zmianie, np.

CONST A=5

oznacza, zdefiniowaną stałą A, która w całym programie ma wartość 5.

Zmienne, w przeciwieństwie do stałych, mogą reprezentować różne wartości. Zbiór wartości, jakie może przyjąć dana zmienna nazywa się jej typem.

zmienna:=wyrażenie

W tym przypadku następuje obliczenie wartości wyrażenia prawostronnego i przypisanie tej wartości odwołaniu do zmiennej występującemu z lewej strony symbolu przypisania := (dwukropek i znak równości). Wartość wyrażenia musi być przy tym zgodna w sensie przypisania z typem zmiennej, np.

a:=5
b[2]:=2*c-s
prawda:=TRUE
tekst:='AmigaE'

W E deklarujemy i ustalamy typ zmiennej komendą DEF, np.

DEF a

Zostanie domyślnie "a" zapisane jako typu LONG.

LONG - a jest typu "długiego", tzn. przyjmuje wartości liczbowe z zakresu $0-$FFFFFFFF (4bajty-32bit)
INT - przyjmuje wartości liczbowe z zakresu $0-$FFFF (2bajty-16bit)
CHAR - znak, przyjmuje wartości liczbowe z zakresu $0-$FF (1bajt-8bit)

Ostanie dwie pozycje typu nie mogą być używane samodzielnie (np. DEF b:INT), a jedynie w danych typu ARRAY lub PTR oraz w obiektach OBJECT.

ARRAY OF xxx jest to tzw. tabela danych.

Dane mogą być razem pogrupowane na różne sposoby, ale prawdopodobnie w większości wypadków będziesz robił tabele, np.

DEF a[132]:ARRAY,
    table[21]:ARRAY OF LONG,
    ints[3]:ARRAY OF INT,
    objs[54]:ARRAY OF myobject

Rozmiar ARRAY-a jest podawany w nawiasach kwadratowych ([ i ]). Domyślnie typ elementów jest zadeklarowany jako CHAR (znak), ale może być zmieniony przez dodanie OF i nazwy typu. Jakolwiek tylko LONG, INT, CHAR i obiekt może być typem.

PTR TO xxx jest tym samym typem co LONG z tą różnicą, że służy do określania jakiego typu jest pamięć, np.

DEF a:PTR TO INT, - pamięć znajdująca się pod adresem a jest typu INT
b:PTR TO CHAR,- pamięć znajdująca się pod adresem b jest typu CHAR
c:PTR TO myobject - pamięć znajdująca się pod adresem c jest opisana w obiekcie myobject

Najlepiej wytłumaczy to przykład:

PROC main()
DEF a:PTR TO CHAR,b:LONG

b:=$12345678
a:={b} - zapisz adres zmiennej b
WriteF('B wynosi:$hn',b)
WriteF('1 bajt b wynosi:$hn',a[])
WriteF('2 bajt:$hn',a[1])
WriteF('3 bajt:$hn',a[2])
WriteF('4 bajt:$hn',a[3])

ENDPROC

Krótki opis działania tego programu:

• deklarujemy zmienną b typu LONG oraz zmienną a typu LONG określająć również, że pamięć pod tym adresem jest typu CHAR
• zmiennej b przypisujemy wartość $12345678
• do zmiennej a pobieramy adres w pamięci zmiennej b
• wyświetlamy ile wynosi zmienna b
• wyświetlamy pierwszy adres pamięci (np. z pod adresu $2000) o wielkości CHAR
• wyświetlamy drugi adres pamięci (np. $2001) o wielkości CHAR
• i tak dalej (np. $2002,$2003,$2004)

Oprócz tych typów istnieje również STRING. Jest on podobny do typu ARRAY z tą różnicą, że operacje zmian mogą być dokonywane tylko przez polecenia wbudowane w E (typu StrCmp(), StrCopy(), StrAdd(), StringF(), etc.) oraz zawiera informacje o długości ciągu i maksymalnej. Dzięki temu STRING nigdy nie urośnie poza maksymalny rozmiar. STRING również jest wstecznie kompatybilny z PTR TO CHAR i oczywiście z ARRAY OF CHAR, ale nie w drugą stronę!.

s[80]:ARRAY OF CHAR - s[80]:STRING
s:PTR TO CHAR; s:=New(80) - s[80]:STRING

Np.

DEF s[80]:STRING - s jest eSTRINGiem o maksymalnej wielkości 80 bajtów

Przykładowe użycie STRINGu:

PROC main()
DEF imie[100]:STRING

WriteF('Jak masz na imie?n')
ReadStr(stdout, imie) - odczytaj tekst z konsoli
WriteF('A wiec masz na imie s.n',imie)

ENDPROC

Operacje na liczbach

W E operatorami arytmetycznymi są:

dodawanie: +
odejmowanie: -
mnożenie: *
dzielenie: /

Przykładowo może wyglądać to tak:

PROC main()
WriteF('2 + 2 to dn',2+2)
WriteF('2 - 2 to dn',2-2)
WriteF('2 * 2 to dn',2*2)
WriteF('2 / 2 to dn',2/2)
ENDPROC

A może teraz porównamy wyniki:

<> - x nie jest równe y
> - x jest większe od y
< - x jest mniejsze od y
>= - x jest większe lub równe y
<= - x jest mniejsze lub równe y

No ale jak sprawdzać?

Tak więc aby sprawdzić czy x>y musimy użyć komendy IF (jeśli). Ogólna postać instrukcji jest następująca:

IF wyrażenie THEN instrukcja

IF x>y THEN JUMP koniec

JEŚLI x>y WTEDY SKOCZ na koniec.

IF x>y
JUMP koniec
ENDIF

IF x>y
WriteF('Hello World!!n')
WriteF('ENDn')
JUMP koniec
ENDIF

IF x>y THEN WriteF('Hello World!!n')
IF x>y THEN WriteF('ENDn')
IF x>y THEN JUMP koniec

No ale może trzeba porównać kilka wartości, do tego służą:

AND - i
OR - lub

tak więc linijka:

IF (x>y) AND (y<x) OR (x<y) THEN WriteF('A jednak...n')

Pamiętaj, aby zawsze używać nawiasów między operatorami AND oraz OR.

Ech ludzie są wygodni, tak więc...

Zamiast pisać x:=x+1 (czyli dodaj do x wartość 1) można pisać x++,to samo jest jeśli chodzi o odejmowanie x:=x-1 to x--.

A jak przejść z jednego typu danych na inny?

Do zmiany STRINGu na LONG (czyli z tekstu na liczbę) służy funkcja Val (tekst), np.

DEF liczba, tekst[80]:STRING
StringF(tekst,'$20001') - ustaw zmiennej tekst (ciąg znaków) '$20001'
liczba:=Val(tekst)

W odwrotną stronę wystarczy użyć StringF(tekst,'d',liczba)