Program automatycznej lub półautomatycznej translacji z języka Delphi do Ady 95

Transkrypt

1 Program automatycznej lub półautomatycznej translacji z języka Delphi do Ady 95 promotor: dr Michał Morawski autor: Marcin Buchwald Wydział Fizyki Technicznej, Informatyki i Matematyki Stosowanej (FTIMS), Politechnika Łódzka

2 Spis treści Bibliografia..3 Spis przykładów4 1. Wstęp.6 2. Podstawy teoretyczne analizy składniowej i teorii kompilatorów Definicja i struktura języka Analiza zdań Konstrukcja diagramu składni Konstrukcja analizatora składniowego dla zadanej gramatyki17 3. Analiza porównawcza języków Ada'95 i Delphi Organizacja programu Podprogramy Instrukcje Typy danych Typy proste Typy strukturalne Typy wskaźnikowe Typy proceduralne Programowanie obiektowe (OOP) Podsumowanie Budowa i działanie programu D2A Struktura programu D2A Działanie programu D2A Translacja struktur obiektowych Enkapsulacja Metody Dziedziczenie Polimorfizm Konstruktor Destruktor Property Typy zagnieżdżone.53 1

3 Instrukcja "with" Rekord z wariantami Funkcje i procedury Dyrektywy kompilatora (pragma) Komentarze Asembler Obsługa wyjątków Zmienne typu obiect Procedury new i dispose Inne konstrukcje nie wspierane przez D2A Załączniki72 A. Notacje BNF, EBNF..72 B. Składnia Object Pascala w EBNF..73 2

4 Bibliografia: 1. Andrzej Pasławski, Programowanie w Delphi 5.0, Edition 2000, Niklaus Wirth, Algorytmy + struktury danych = programy, WNT, Niklaus Wirth, Wstęp do programowania systematycznego, WNT, Ada95 reference manual, dołączony do pakietu GNAT 5. Programing with Delphi, dołączony do pakietu Delphi A Brief History of Pascal, 7. Visual Studio.NET: C# introduction, 8. Jerzy Grębosz, Symfonia C++, Oficyna Kallimach,

5 Spis przykładów 1. Przykład 2.1 definicja prostego języka.9 2. Przykład 2.2 definicja prostego języka.9 3. Przykład 2.3 definicja prostego języka Przykład 2.4 definicja prostego języka Przykład 2.5 definicja prostego języka Przykład 2.6 program analizatora prostego języka Przykład 3.1a organizacja programu Delphi Przykład 3.1b organizacja programu Ada Przykład 3.2 instrukcja loop w Adzie Przykład 3.3 typy proste w Adzie Przykład 3.4 typy strukturalne tablice Przykład 3.5 typy strukturalne rekordy Przykład 3.6 typy wskaźnikowe Przykład 3.7 typy proceduralne Przykład 4.2a metody Delphi Przykład 4.2b metody Ada Przykład 4.3 polimorfizm Przykład 4.4a polimorfizm Delphi Przykład 4.4b polimorfizm Ada Przykład 4.5a konstruktor Delphi Przykład 4.5b konstruktor Ada Przykład 4.6a property Delphi Przykład 4.6b property Ada Przykład 4.7a typy zagnieżdżone Delphi Przykład 4.7b typy zagnieżdżone Ada Przykład 4.8a rekord z wariantami Delphi Przykład 4.8b rekord z wariantami Ada Przykład 4.9a przekazywanie parametrów do podprogramu Delphi Przykład 4.9b przekazywanie parametrów do podprogramu Ada Przykład 4.10 zwracanie wartości funkcji w Delphi Przykład 4.11 dyrektywy kompilatora w Delphi Przykład 4.12 dyrektywy kompilatora w Delphi62 4

6 33. Przykład 4.13 dyrektywy kompilatora w Delphi Przykład 4.14 dyrektywy kompilatora w Delphi Przykład 4.15 komentarze Przykład 4.16 kod asemblera w Delphi Przykład 4.17 przetłumaczony kod asemblera Przykład 4.18 obsługa wyjątków Przykład 4.19 blok finally Przykład 4.20 typ object70 5

7 1. Wstęp Celem tej pracy jest stworzenie narzędzia, za pomocą którego programista mógłby w szybki sposób tłumaczyć kod napisany w języku Object Pascal (pakiet Delphi) do języka Ada 95, nazywanego w niniejszej pracy po prostu Adą. Język Delphi, następca popularnego Turbo Pascala firmy Borland, w przeciągu ostatnich lat stał się jednym z najpopularniejszych środowisk programistycznych na platformę systemu operacyjnego Microsoft Windows, a ostatnio także dla systemu Linux (Kylix). Od tego czasu powstało dużo bibliotek napisanych dla tego języka. Zaistniała potrzeba udostępnienia niektórych z nich dla potrzeb programistów innych języków, w tym Ady. Ada w porównaniu z Delphi oferuje znacznie większą uniwersalność (można pisać w niej m. in. sterowniki, gry, programy biznesowe a nawet systemy operacyjne), bezpieczeństwo, zgodność ze standardami i lepsze kompilatory (np. GNAT) [4]. Korzystanie z bibliotek napisanych w Delphi przez programy Ady nie zawsze jest możliwe. Często jedynym wyjściem jest przepisanie takich bibliotek na nowo tym razem w Adzie. Pomocnym narzędziem w tej czynności jest program do automatycznej lub półautomatycznej translacji z Delphi do Ady 95. Oba te języki wywodzą się z języka Pascal. Powstał on w późnych latach sześćdziesiątych ubiegłego wieku, w zastępstwie pierwszego języka wysokiego poziomu jakim był Algol (1960 r.) [2], który pomimo czytelnej, strukturalnej i systematycznie zdefiniowanej składni nie oferował tak podstawowych typów danych jak wskaźniki czy typ znakowy. Twórcą Pascala był prof. Niklaus Wirth z instytutu ETH w Zurichu. Poza uproszczeniem lub też odrzuceniem niektórych zbędnych, przestarzałych konstrukcji, Wirth dodał możliwość definiowania nowych typów danych na podstawie innych, już istniejących [6]. Dodatkowo język Pascal zaopatrzono w tzw. dynamiczne struktury danych, czyli takie struktury, które mogą zmieniać swój rozmiar w trakcie trwania programu (np. możliwość implementacji kolejek, stosów oraz tablice dynamiczne). Przyczyną sukcesu tego języka, oprócz wymieniowych wcześniej zalet, stała się budowa kompilatora Pascala, który produkował prosty kod pośredni, niezależny od konkretnej architektury (P-code). Inny moduł interpretował P-code i tłumaczył go na kod maszynowy dla danego procesora. To spowodowało, że przenoszenie kompilatora stało się prostsze trzeba było za każdym razem pisać jedynie interpreter P-code, a nie cały kompilator. Na podobnej zasadzie działa między innymi język Java. Tu kod pośredni tzw. bytecode jest interpretowany za pomocą maszyny wirtualnej javy (ang. java virtual machine). Najbardziej popularnym kompilatorem stał się Turbo Pascal firmy Borland 6

8 późniejszych twórców Delphi. Pascal miał potężny wpływ na inne języki, między innymi na Adę, Delphi, Modulę-2, Simulę, Smalltalk, Cedar, Oberon, Component Pascal a nawet na Visual Basic. W związku z tym, że języki Delphi i Ada 95 mają wspólne korzenie, istnieją znaczne podobieństwa w podstawowych strukturach języka. Z założenia translator powinien wyręczyć programistę w tłumaczeniu pewnych podstawowych konstrukcji, które stanowią znaczną część kodu programu. Takie fragmenty języka jak pętle, instrukcje warunkowe, definicje podprogramów czy rekordów mogą być łatwo przetłumaczone za pomocą programu translacyjnego. Inne z kolei konstrukcje są w obu językach bardzo różne. Jest tak w przypadku programowania obiektowego (OOP), które nie było częścią Pascala wzorcowego. Ada i Delphi implementują to zagadnienie w krańcowo różne sposoby. Kwestia prawidłowego przetłumaczenia takich konstrukcji stanowi dla translatora największe wyzwanie. Niektóre konstrukcje nie są tłumaczone (np. typy set of), inne zaś częściowo (np. typy interface). Powodem tego jest zazwyczaj brak w Adzie odpowiednika danej konstrukcji z Delphi. Dodatkowo Ada została zaprojektowana z myślą o minimalizacji błędów, które programista popełnia pisząc kod programu. Stąd język ten jest bardzo restrykcyjny i wiele rzeczy (takich jak przekazywanie do funkcji parametrów przez referencję) jest niedozwolona. W końcu Ada jest językiem bardziej uniwersalnym od Delphi. Istnieje wiele implementacji Ady na wiele platform i systemów operacyjnych, Delphi zaś zaprojektowano na platformę PC/Windows (od niedawna także PC/Linux). Tam gdzie translator nie jest w stanie przetłumaczyć poprawnie danej konstrukcji, powinien wstawić o tym informację dla użytkownika programisty, tak by mógłby on zrobić to samodzielnie. Na koniec kilka uwag o formalnej stronie pracy. W pracy użyto czcionki Times New Roman. Dla kodu w przykładach użyto czcionki Curier. Dla zwiększenia czytelności przykładów niektóre elementy języka Ada i Delphi (w tym słowa kluczowe) zostały napisane tłustym drukiem. Odniesienia do literatury zostały umieszczone w nawiasach kwadratowych. 7

9 2. Podstawy teoretyczne analizy składniowej i teorii kompilatorów [2] Rozdział ten w sposób teoretyczny traktuje o tym, co wszyscy programiści doskonale znają - interpretacji i kompilacji. Narzędzia komputerowe służące do przetworzenia tekstu napisanego w języku programowania (programu) to translatory. Translatory tłumaczą kod programu do postaci wykonywanej przez komputer, lub nadającej się do przetworzenia przez inny program. Przykładem tych pierwszych są translatory popularnych języków programowania, takich jak C, które tłumaczą kod w języku programowania do kodu maszynowego, wykonywalnego przez procesor komputera. Przykładem tych drugich mogą być translatory języków skryptowych, na przykład bash. Te z kolei, zamieniają treść skryptu na sekwencję poleceń wykonywanych przez system operacyjny. W tym rozdziale podane zostaną podstawowe definicje i reguły teorii kompilacji a w szczególności analizy strukturalnej języka. 2.1 Definicja i struktura języka Na wstępie należy zdefiniować samo pojęcie języka, jakie będzie używane w niniejszej pracy. Podstawą każdego języka jest słownik. Elementy słownika są zazwyczaj nazywane słowami; w świecie języków formalnych nazywa się je symbolami (podstawowymi). Cechą charakterystyczną języków formalnych (formalizacja polega na dokładnym określeniu alfabetu języka, tj. znaków, których można używać w tekstach pisanych w tym języku, określenia dopuszczanego łączenia tych znaków - gramatyki języka) jest to, że pewne ciągi słów są rozpoznawane jako poprawne, dobrze zbudowane zdania języka. O innych ciągach słów mówi się, że są niepoprawne lub źle zbudowane. O tym, że ciąg słów jest zdaniem poprawnym lub nie, decyduje gramatyka, mówiąc inaczej składnia lub struktura języka. Składnia to zbiór reguł lub formuł (produkcji), określający zbiór (formalnie poprawnych) zdań. Ważniejsze jest jednak to, że taki zbiór reguł nie tylko pozwala nam decydować, czy dany ciąg słów jest zdaniem, ale także dla konkretnego zdania określa jego strukturę, która jest pomocna w rozpoznaniu znaczenia zdania. Jasne jest więc, że składnia i semantyka (znaczenie) są blisko ze sobą powiązane. Dlatego definicje strukturalne są traktowane jako definicje pomocnicze dla innych celów. 8

10 Rozważmy np. zdanie Ala ma kota. Słowo Ala jest tu podmiotem, ma orzeczeniem, zaś kota - dopełnieniem. Można zdefiniować język za pomocą składni: PRZYKŁAD 2.1 <zdanie> ::= <podmiot><orzeczenie><dopełnienie> <podmiot> ::= Ala Zuzia <orzeczenie> ::= ma karmi <dopełnienie> ::= psa kota Trzy powyższe wiersze pozwalają stwierdzić, że (1) Zdanie składa się z następujących po sobie podmiotu, orzeczenia i dopełnienia. (2) Podmiot jest albo pojedynczym słowem Ala, albo słowem Zuzia (3) Orzeczenie jest albo pojedynczym słowem ma, albo słowem karmi (4) Dopełnienie jest albo pojedynczym słowem kota, albo słowem psa Zatem zdanie Ala ma kota należy do języka zdefiniowanego w przykładzie 2.1. Inne poprawne zdania tego języka to np. Zuzia karmi psa, Ala karmi kota, Zuzia ma psa. Podstawowa koncepcja jest wiec następująca: zdanie języka można wyprowadzić z początkowego symbolu <zdanie> stosując kolejno reguły zastępowania. Formalizm, za pomocą którego zdefiniowano język z przykładu 2.1, zwany jest notacją BNF (Backus-Naur-Form) [zał. A], po raz pierwszy użytą do zdefiniowania Algolu 60. Konstrukcje zdaniowe <zdanie>, <podmiot>, <orzeczenie>, <dopełnienie> zwane są symbolami pomocniczymi (nieterminalnymi), słowa koty, psy, śpią, jedzą nazywają się symbolami końcowymi (terminalnymi), reguły zaś są nazywane produkcjami. Symbole ::= i / nazywa się metasymbolami notacji BNF. Jeśli w celu skrócenia zapisu użyjemy pojedynczych dużych liter do oznaczania symboli końcowych, to przykładowa definicja języka przyjmie następującą postać: PRZYKŁAD 2.2 S::=AB A::=x y B::=z w 9

11 Język zdefiniowany przez składnię zawiera cztery zdania xz, yz, xw, yw. W celu uściślenia omawianych pojęć wprowadzimy następujące definicje matematyczne: (1) Język L=L(T, N, P, S) jest określony przez (a) słownik symboli końcowych T; (b) zbiór symboli pomocniczych (kategorii gramatycznych) N; (c) zbiór produkcji (reguł syntaktycznych) P; (d) symbol S (należący do N), zwany symbolem początkowym. (2) Język L=L(T, N, P, S) jest zbiorem ciągów symboli końcowych ξ, które mogą być wyprowadzone z S zgodnie z podana poniżej regułą 3. L={ξ S * ξ i ξ T*} (liter greckich używamy dla oznaczenia ciągów symboli). T* oznacza zbiór wszystkich ciągów symboli z T. (3) Ciąg δ n może być wyprowadzony z ciągu δ 0 wtedy i tylko wtedy, jeśli istnieją ciągi δ 1, δ 2,, δ n takie, że każdy δ i może być bezpośrednio wyprowadzony z δ i-1 zgodnie z podaną poniżej regułą 4: (δ 0 * δ n ) ((δ i-1 δ i ) dla i=1,,n) (4) Ciąg η może być bezpośrednio wyprowadzony z ciągu ξ wtedy i tylko wtedy, jeśli istnieją ciągi α, β, ξ, η takie, że (a) ξ=αξ β (b) η=αη β (c) P zawiera produkcję ξ ::= η Uwaga: notacji α::=β 1 β 2 β n używamy jako skróconego zapisu zbioru produkcji α::=β 1, α::=β 2,, α::=β n. Język nazywamy bezkontekstowym wtedy i tylko wtedy, gdy można go zdefiniować za pomocą zbioru produkcji bezkontekstowych. Produkcja jest bezkontekstowa wtedy i tylko wtedy, gdy jest postaci: A::=ξ ( A N, ξ (N T)* ) tj. jeśli jej lewa strona składa się z pojedynczego symbolu pomocniczego i może być zastąpiona przez ξ, niezależnie od kontekstu, w jakim pojawia się A. Jeśli produkcja jest postaci αaβ::=αξβ 10

12 to zwana jest kontekstową, ponieważ zastąpienie A przez ξ może się zdarzyć tylko w kontekście α i β. 2.2 Analiza zdań Podstawowy zadaniem translatora jest nie generowanie, lecz rozbiór zdań i struktur zdaniowych. Opracowanie algorytmów rozbioru zdań jest zadaniem teorii analizy składniowej. Pożądanym założeniem jest by koszt liczenia związany z analizą zdania był funkcją liniową jego długości, a co najwyżej nie przekraczał n*ln(n) gdzie n jest długością zdania. Pierwszą konsekwencją tego założenia jest fakt, że określenie kolejnego kroku analizy musi zależeć tylko od obecnego stanu obliczeń oraz pojedynczego, aktualnie wczytanego symbolu. Drugą konsekwencją jest to, że żadnego z kolejnych kroków analizy nie można cofnąć. Metoda rozbioru spełniająca oba warunki nazywa się analizą bez powrotów z wyprzedzeniem o jeden symbol (ang. one-symbollookahead without backtracking). Taką analizą jest rozbiór generacyjny (zstępujący, ang. topdown). Polega ona na odtworzeniu kroków generujących zdanie od symbolu początkowego. Np. dla zdania psy jedzą trzeba określić czy należy ono do języka zdefiniowanego w przykładzie 1. Zdanie tego języka można wyprowadzić tylko z symbolu początkowego <zdanie>. Z definicji zdanie poprawne jest tylko wtedy, gdy składa się z podmiotu i następującego po nim orzeczenia. Teraz trzeba określić czy pierwszą cześć zdania można wyprowadzić z symbolu nieterminalnego <podmiot>. Jest to prawda, gdyż słowo (symbol) psy jest jednym z alternatywnych symboli terminalnych definiujących <podmiot>. Następnie zajmujemy się (wczytujemy) drugi symbol: jedzą. Analogicznie postępujemy w dalszym ciągu sprawdzając, czy to słowo jest <orzeczeniem>. Poniższa tabela ilustruje tę metodę. <zdanie> Ala ma kota <podmiot> <orzeczenie><dopełnienie> Ala ma kota Ala <orzeczenie><dopełnienie> Ala ma kota <orzeczenie><dopełnienie> ma kota ma <dopełnienie> ma kota <dopełnienie> kota 11

13 Kota kota PRZYKŁAD 2.3 Zdefiniujmy język: S ::= A B A ::= xa y B ::= xb z Spróbujmy dokonać rozbioru zdania xxxz S A xa A xa A xa A xxxz xxxz xxxz xxz xxz xz xz z Analiza się nie udała. Przyczyną tego jest pierwszy krok. Gdybyśmy zastąpili S przez B analiza powiodła by się. Decyzja o tym czy S ma być zastąpione przez A czy B, nie może być podjęta na podstawie aktualnego stanu obliczeń oraz aktualnie wczytanego symbolu. Problem rozwiązałaby tzw. analiza z powrotami, która z grubsza polega na tym, że analiza odbywa się do momentu wystąpienia ewentualnego błędu, a następnie następowałby powrót aż do kroku powodującego trudności. Podstawową wadą takiego rozwiązania jest to, że nie ma ograniczenia na ilość kroków, które należy unieważnić. Zatem algorytmy te nie spełniają podstawowego założenia efektywności (dotyczącego kosztu liczenia związanego z analizą zdania). 12

14 S Xxxz B Xxxz xb Xxxz B Xxz xb Xxz B Xz xb Xz B z z z W związku z tym podstawową konsekwencją analizy bez powrotów z wyprzedzeniem o jeden symbol jest następująca reguła: REGUŁA 2.1 Dla zadanej produkcji A ::= ξ 1 ξ 2 ξ n zbiory pierwszych symboli w zdaniach, które mogą być wyprowadzone z ξ i muszą być rozłączone, tzn. pierw(ξ i ) pierw(ξ j ) =, dla wszystkich i j Zbiór pierw(ξ) jest zbiorem wszystkich symboli końcowych, które mogą wystąpić na pierwszej pozycji w zdaniach wyprowadzonych z ξ. Zbiór ten można wyznaczyć wg następujących zasad: (1) jeśli pierwszy symbol argumentu jest symbolem końcowym, to pierw(aξ)={a} (2) jeśli pierwszy symbol jest symbolem pomocniczym i istnieje produkcja A ::= α 1 α 2 α n to pierw(aξ) = pierw(α 1 ) pierw(α 2 ) pierw(α n ) PRZYKŁAD 2.4 S ::= Ax A ::= x ε 13

15 gdzie ε oznacza pusty ciąg symboli. Dokonajmy rozbioru zdania x. S x Ax x xx x x --- Sytuacja ta jest zwana problemem pustego słowa. Wynikła ona z zastosowania produkcji A ::= x zamiast A ::= ε. Jak uniknąć tej pułapki mówi drugą reguła: REGUŁA 2.2 Dla każdego symbolu A N, z którego można wyprowadzić pusty ciąg symboli (A *ε), zbiór pierwszych symboli musi być rozłączny ze zbiorem symboli, które mogą następować po dowolnym ciągu wyprowadzonym z A, tzn. pierw(a) nast(a) = Zbiór nast(a) wyznacza się następująco: dla każdej produkcji P i postaci X ::= ξaη przez S i oznaczmy pierw(η i ). Suma wszystkich takich zbiorów S i tworzy zbiór nast(a). Jeśli z co najmniej jednego η i możena utworzyć pusty ciąg symboli, to zbiór nast(x) należy włączyć do nast(a). W przykładzie mamy: pierw(a) = nast(a) ={x} 2.3 Konstrukcja diagramu składni REGUŁY KONSTRUKCJI DIAGRAMU A1. Każdy symbol pomocniczy A, dla którego istnieje produkcja 14

16 A::=ξ 1 ξ 2 ξ n zostaje przekształcony na diagram symbolu A o strukturze określonej przez prawą stronę produkcji, zgodnie z regułami A2-A6. A2. Każde wystąpienie symbolu końcowego x w ξ i odpowiada instrukcji rozpoznającej dany symbol i pobierającej kolejny symbol z ciągu wejściowego. W diagramie jest ono reprezentowane następująco: x A3. Każde wystąpienie symbolu pomocniczego B w ξ i odpowiada uaktywnieniu podprogramu opisanego diagramem dla symbolu B. Oto reprezentacja graficzna: B A4. Produkcja postaci A::=ξ 1 ξ 2 ξ n jest przekształcana na diagram: ξ 1 ξ 2 ξ n gdzie ξ i powstaje z α poprzez stosowanie reguł A2-A6 A5. Ciąg ξ postaci 15

17 ξ::=α 1 α 2 α m Przekształca się na diagram: α 1 α 1 α 1 gdzie α i powstaje z α poprzez stosowanie reguł A2-A6 A6. Jeśli ξ jest postaci ξ::={α} to konstruujemy następujący diagram: α gdzie α powstaje z α poprzez stosowanie reguł A2-A6 PRZYKŁAD 2.5 A ::= x (B) B ::= AC C ::= {+A} W tej gramatyce symbole +, x, (, ) są symbolami końcowymi, podczas gdy nawiasy { i }, należące do rozszerzonej notacji BNF są metasymbolami oznaczającymi iteracje. Przykładowe zdania tego języka to: x (x) (x+x) ((x)) W wyniku zastosowania reguł A1-A6 otrzymamy trzy diagramy: 16

18 A ( B ) x B A C C A + Po redukcji diagram ten wygląda następująco: A ( A ) A + x 2.4 Konstrukcja analizatora składniowego dla zadanej gramatyki Na podstawie deterministycznego diagramu składni dla zadanego języka można opracować program dokonujący rozbioru zdań. Diagram bowiem w swej istocie stanowi schemat blokowy 17

19 takiego programu. Istnieją reguły, które w prosty sposób pozwalają konstruować program na podstawie diagramów syntaktycznych, ew. zbioru notacji BNF. REGUŁY PRZEJŚCIA OD DIAGRAMU DO PROGRAMU Założenia przyjęte dla reguł B1-B6: - Kod programu analizatora jest w tym wypadku zapisany w języku Ada 95, - funkcją pobierającą symbole (tokeny) ze strumienia wejściowego jest nast_znak, - zmienną przechowującą aktualny analizowany symbol jest znak, - funkcję otrzymaną dla diagramu S będziemy oznaczać przez T(S). B1. Każdy diagram należy zastąpić deklaracją procedury zgodnie z regułami B2-B6. B2. Ciąg elementów postaci S 1 S 2 S n należy zastąpić instrukcją begin T(S 1 ); T(S 2 ); T(S n ); end B3. Diagram postaci 18

20 S 1 S 2 S n należy zastąpić instrukcją case znak do when L 1 => T(S 1 ); when L 1 => T(S 2 ); when L 1 => T(S n ); end case gdzie { L i i=1,2,,n } oznacza zbiór symboli poczatkowych. B4. Diagram postaci S należy zastąpić instrukcją loop exit when znak /= L; T(S); end loop gdzie T(S) otrzymano zgodnie z regułami B2-B6, L=pierw(S). B5. Element diagramu oznaczający inny diagram A (symbol nieterminalny) należy zastąpić wywołaniem procedury implementującej diagram A. 19

21 B6. Element diagramu oznaczający symbol końcowy x należy zastąpić instrukcją: if znak=x then x:=nast_znak; else blad; end if; gdzie blad jest procedurą wywoływaną przy napotkaniu niepoprawnej konstrukcji. PRZYKŁAD 2.6 Funkcje analizatora dla gramatyki zdefiniowanej w przykładzie 2.5. Założono, że istnieje funkcja nast_znak, która podaje kolejne symbole końcowe, zmienna znak, która reprezentuje aktualnie analizowany symbol. W razie napotkania błędu funkcja zwraca wartość logiczną fałsz (false), w przypadku pomyślnej analizy zwracana jest wartość logiczna prawda (true). function A return boolean; function B return boolean; function C return boolean; function A return boolean is ok: boolean; begin if znak = x then znak := nast_znak; elsif znak = ( then znak := nast_znak; ok := B; if not ok then return false; end if; else return false; end if; 20

22 return true; end A; function B return boolean is ok: boolean; begin ok := A; if not ok then return false; end if; ok := C; if not ok then return false; end if; return true; end A; function C return boolean is ok: boolean; begin loop exit when znak /= + ; znak := nast_znak; ok := A; if not ok then return false; end if; end loop; return true; end A; Po uproszczeniu diagramu mamy tylko jedną funkcję, działanie pozostaje identyczne. function A return boolean is ok: boolean; begin if znak = x then znak := nast_znak; elsif znak = ( then znak := nast_znak; loop 21

23 exit when znak /= + ; znak := nast_znak; ok := A; if not ok then return false; end if; end loop; else return false; end if; return true; end A; A oto procedura główna programu analizatora: procedure analizuj is begin znak := nast_znak; if A then put_line( zdanie poprawne ); else put_line( zdanie nie należy do języka ); end if; end analizuj; 22

24 3. Analiza porównawcza języków Ada 95 i Delphi Delphi to nazwa narzędzia programistycznego oraz dialektu języka Object Pascal produkowanego przez firmę Borland. Object Pascal jest językiem wysokiego poziomu oferującym metody programowania zarówno strukturalne jak i obiektowe. Jak zostało wspomniane na wstępie, fakt, że oba języki mają wspólnego przodka (Pascal) implikuje duże podobieństwa w ich strukturach podstawowych, takich jak instrukcje proste (np. instrukcja przypisania), warunkowe oraz deklaracje rekordów. Delphi i Ada 95 należą do języków algorytmicznych, zorientowanych obiektowo i modułowych. Historia powstania i rozwoju obu języków jest odmienna. Ada jest dzieckiem programu Department of Defense Common High Order Language, który został zainicjowany w roku Celem było stworzenie języka programowania wysokiego poziomu (High Order Language) odpowiedniego dla komputerowych systemów typu embeded, wykorzystywanych przez Departament Obrony USA (Departament of Defence, DoD). Aby określić wymagania stawiane takim językom powstała grupa High Order Language Working Group (HOLWG). Wypracowała ona dokument Directive opisujący te wymagania. Na tej podstawie sporządzono listę języków spełniających kryteria przyjęte w Directive Były to COBOL, FORTRAN, TACPOL, CMS-2, SPL/1, oraz JOVIAL J3 i J73. Analizy ekonomiczne dowiodły, że użycie jednego, uniwersalnego języka wyłoby bardziej zyskowne, zarówno pod względem kosztów jak i niezawodności oprogramowania. Odpowiedzią na to był język Ada [4]. Delphi to bezpośredni potomek pakietu Turbo Pascal najpopularniejszego narzędzia programistycznego na platformę MsDOS. Prostota budowania interfejsu użytkownika za pomocą biblioteki VCL (Visual component Library), łatwy, zunifikowany dostęp do baz danych oraz możliwość korzystania z najnowszych technologii (COM, CORBA [5]) spowodował, że pakiet ten stał się idealnym narzędziem do budowy aplikacji biznesowych. Podstawową zaletą Delphi jest możliwość prostego, intuicyjnego, a przede wszystkim szybkiego produkowania aplikacji, co w dodatku nie wymaga dużego doświadczenia programistycznego. Inne cele, które przyświecały powstaniu tych języków spowodowały, że pomimo wielu często powierzchownych podobieństw bardzo się od siebie różnią. 23

25 3.1 Organizacja programu Zacznę od organizacji programu. Oba języki oferują możliwość modularyzacji kodu. W Delphi moduły mają nazwę Unit. Język nie oferuje możliwości zagnieżdżania modułów. Nazwa pliku z tekstem modułu powinna pokrywać się z jego nazwą zadeklarowaną po słowie kluczowym unit (oczywiście uzupełnioną o rozszerzenie pas). Każdy plik z modułem dzieli się na dwie części: interface i implementation. Część interface składa się z deklaracji tych typów, zmiennych, stałych i podprogramów, które będą widoczne poza modułem, zaś w części implementation znajduje się ich definicja. Procedura główna programu definiowana jest w pliku o rozszerzeniu dpr (od Delphi Project). Jeśli programista chce używać typów, zmiennych i in. zadeklarowanych w module X to musi to zadeklarować za pomocą konstrukcji uses X. Np. PRZYKŁAD 3.1a unit A; interface //początek części interface deklaracje publiczne uses B, C; //deklaracja korzystania z modułów B i C implementation //implementacja modułu uses D,E; //deklaracja korzystania z modułów D i E //nie są one widoczne w części interface end. W Adzie moduły noszą nazwę pakiety (package). Istnieje możliwość deklarowania pakietów zagnieżdżonych (tj. definiowanie podpakietów). Odpowiednikiem części interface z Delphi jest deklaracja modułu w pliku o rozszerzeniu ads. Implementacja jest umieszczona w pliku o rozszerzeniu adb. Odpowiednikiem konstrukcji uses X jest with X; use X. With X sprawia, że zawartość modułu jest widoczna a use X pozwala pominąć przedrostek X. przed dowolnym typem, zmienną czy stałą z X. 24

26 PRZYKŁAD 3.1b plik a.ads (interfejs modułu): with B; use B; -- deklaracja korzystania z modułów B i C with C; use C; package A is --początek odpowiednika części interface end A. plik a.adb: with D; use D; -- deklaracja korzystania z modułów D i E with E; use E; package body A is --początek odpowiednika części implementation end A. Podsumowując: Ada oferuje prezentuje bardziej zaawansowane możliwości organizacji kodu od Delphi, pozwala na porządkowanie kodu w strukturze drzewiastej. Delphi zaś nie oferuje nic poza prostą modularyzacją. Na szczęście na potrzeby translacji to wystarczy, w Adzie łatwo osiągnąć podobną strukturę jak w Delphi. 3.2 Podprogramy Object Pascal odziedziczył po Pascalu całą dziedzinę dotyczącą programowania strukturalnego. Mamy więc podział podprogramów na funkcje podprogramy zwracające wyniki swoich obliczeń oraz procedury nie robiące tego. Definicja procedury składa się z jej nagłówka oraz bloku. Blok zawiera część deklaracyjną (w której deklaruje się stałe, zmienne, typy i podprogramy lokalne dla procedury) oraz właściwą treść procedury, pomiędzy słowami begin i end. W nagłówku procedury, 25

27 po jej nazwie, może wystąpić lista parametrów formalnych ujęta w nawiasy. Podobnie deklaruje się funkcje. W nagłówku, po dwukropku, określany jest typ zwracanej przez funkcję wartości. Deklaracje procedur i funkcji mogą być zagnieżdżane w przeciwieństwie do takich języków jak C/C++ czy Java. W Adzie struktura podprogramów wygląda niemal identycznie, różnice są głównie natury kosmetycznej. Tak więc na końcu procedury czy funkcji stoi słowo kluczowe end uzupełnione przez nazwę podprogramu, typ wartości zwracanej przez funkcję podaje się po słowie kluczowym return, a nie po dwukropku jak ma to miejsce w Delphi, itd. Istotne dla translatora różnice w podejściu do podprogramów tkwią głównie w sposobie zwracania wartości przez funkcje oraz nieco innej strukturze parametrów formalnych. Zostało to szczegółowo omówione w rozdziale czwartym (par ). 3.3 Instrukcje Instrukcje proste, do których zalicza się: - instrukcje przypisania, np. var_a := value; - instrukcje wywołanie podprogramu proc(2); //wywołanie procedury wart:=fun(1,2,3); //wywołanie funkcji - instrukcje skoku do etykiety goto etykieta; w obu językach są identyczne. Instrukcje strukturalne to instrukcje, które zawierają jedna lub więcej instrukcji prostych, oraz ewentualne wyrażenia warunkowe decydujące o wykonaniu tych poleceń. W Delphi najprostszą z nich jest instrukcja grupująca, tzn. sekwencja dowolnych instrukcji umieszczona pomiędzy słowami kluczowymi begin i end, poprzedzielanych średnikiem. Może być to (w szczególności) instrukcja pusta, tj. brak instrukcji. Ada oferuje instrukcje grupującą z możliwością definiowania lokalnych zmiennych, stałych, typów i podprogramów. Jej składnia to: declare <definicja lokalnych zmiennych, stałych, typów i podprogramów > begin 26

28 <sekwencja instrukcji> end Blok instrukcji pomiędzy słowami kluczowymi begin i end jest w sensie syntaktycznym jak i semantycznym zbieżny z instrukcja grupującą w Delphi. W Adzie instrukcja pusta to null. Równie ważną instrukcją strukturalną jest instrukcja warunkowa. W Object Pascalu ma ona postać: if <warunek> then <instrukcja1>; else <instrukcja2>; Część else jest opcjonalna. Należy zauważyć, że <instrukcja1> i <instrukcja2> mogą być instrukcjami strukturalnymi, w szczególności instrukcjami grupującymi. Jeśli w miejsce <instrukcja2> wstawić inną instrukcję warunkową to otrzyma się instrukcję wyboru, np. if <warunek1> then begin //początek instrukcji grupującej <sekwencja instrukcji> end else if <warunek2> then //w bloku else mamy inna instrukcję warunkową <instrukcja1> else //blok else dla drugiej instrukcji warunkowej <instrukcja2> end A oto odpowiednik w Adzie: if <warunek1> then <sekwencja instrukcji1> elsif <warunek2> then <sekwencja instrukcji2> 27

29 else <sekwencja instrukcji3> end if Jak widać instrukcja warunkowa w Adzie potrafi samodzielnie grupować inne instrukcje, przez co zbędny staje się blok begin..end. Dodatkowo dzięki słowu kluczowemu elsif można za pomocą jednej instrukcji warunkowej zapisać to, co w Delphi wymagałoby kilku (zagnieżdżonych, po słowie kluczowym else). Daje to nieco większą przejrzystość kodu. Pokrewną instrukcją jest instrukcja wyboru (case). W zależności od selektora (typu porządkowego) mogą być podejmowane różne akcje. Struktura tej instrukcji została pokazana na poniżej: Delphi: case <selektor> of <wartość1>: <instrukcja1>; <wartość2>: <instrukcja2>; <wartość3>: <instrukcja3>; else: <instrukcjan>; end Ada 95: case <selektor> is when <wartość1> => <instrukcja1>; when <wartość2> => <instrukcja2>; when <wartość3> => <instrukcja3>; when others => <instrukcjan>; end W obu przypadkach wykonanie danej partii kodu (<instrukcja1>, <instrukcja2>, ) zależy od wartości selektora. Opcjonalny blok else (when others w Adzie) jest wykonywany gdy selektor jest 28

30 różny od wartości określonych explicite w poprzednich blokach. Różnice na poziomie syntaktycznym są niewielkie, sprowadzają się do użycia nieco innych słów kluczowych i symboli przy określaniu warunków. Struktura <wartość>: w Delphi odpowiada strukturze when <wartość> => w Adzie. I analogicznie else: jest równoważne when others =>. Na poziomie semantycznym różnica jest jedna: w Delphi jeśli selektor nie pasuje do żadnej wartości oraz brak jest bloku else to żadna partia instrukcji case nie zostanie wykonana, kompilator Ady nie pozwala by tego typu sytuacja zaszła, traktuje to jako błąd. Translator radzi sobie z tym problemem dodając automatycznie when others => null; jeśli w instrukcji case brak jest bloku else. Ważnymi instrukcjami strukturalnymi są instrukcje pętli. I w tym przypadku Ada oferuje ich bogatszy wachlarz. W Object Pascalu mamy do dyspozycji instrukcje while, repeat i for. Dwie pierwsze różnią się tylko tym, że w instrukcji while najpierw sprawdza się warunek kontynuacji pętli, potem zaś wykonuje instrukcje, w instrukcji repeat jest odwrotnie. Pętla for ma zastosowanie wówczas, gdy ilość iteracji jest znana. Pętla zostanie wykonana dla każdej wartości zmiennej sterującej (typu porządkowego) z określonego przedziału: for <zmienna> := <wartość minimalna> to <wartość maksymalna> do <instrukcja>; Lub dla zmiennej malejącej: for <zmienna> := <wartość maksymalna > downto <wartość minimalna> do <instrukcja>; W Adzie pętla jest implementowana poprzez instrukcję loop. Istnieje kilka wariantów tej instrukcji. Np. Odpowiednik while w Adzie jest następujący: while <warunek> loop 29

31 <sekwencja instrukcji oddzielonych średnikami> end loop; Dla pętli for mamy: for <zmienna> in <wartość minimalna>.. <wartość maksymalna> loop <sekwencja instrukcji oddzielonych średnikami> end loop; Dla zmiennej malejącej: for <zmienna> in reverse <wartość minimalna>.. <wartość maksymalna> loop <sekwencja instrukcji oddzielonych średnikami> end loop; Dodatkowo instrukcja loop w Adzie może przyjąć bardzie ogólną i elastyczną postać: loop <sekwencja instrukcji oddzielonych średnikami> end loop; wyjście w pętli gwarantuje tutaj użycie instrukcji exit, która może wystąpić wielokrotnie w bloku loop. Na przykład: PRZYKŁAD 3.2 loop b := fun1(x); exit when b<6; --wyjście pod warunkiem b<6 c := b fun2(x); exit when c>2 or c<-1; --wyjście pod warunkiem (c>2 or c<-1) end loop; 30

32 Tutaj z pętli można wyjść w dwóch miejscach za każdym razem warunek wyjścia jest inny. Aby osiągnąć podobną funkcjonalność w Delphi należy posłużyć się poleceniem break w połączeniu z instrukcją warunkową. 3.4 Typy danych Object Pascal jest (jak Ada) językiem w którym dane zawsze są określonego typu. Definiuje dość surowe reguły konwersji danych, Ada pod tym względem jest jeszcze bardziej restrykcyjna. Zatem oba języki należą do grupy tzw. strong typed languages. Typy w Object Pascalu dzieli się na: - proste, - łańcuchowe, - strukturalne, - wskaźnikowe, - proceduralne Pomimo, że Ada oferuje tu nieco odmienną hierarchię (niewątpliwie o wiele bardziej złożoną) posłużę się tym podziałem do opisu porównawczego typów danych obu języków Typy proste Do tej grupy zalicza się typy porządkowe i rzeczywiste. Typy porządkowe to: całkowitoliczbowe, znakowe, logiczne, wyliczeniowe oraz okrojone. Do typów całkowitoliczbowych należą m. in. Integer, Cardinal, Byte, Word, LongInt oraz Int64. Różnią się one od siebie ilością bitów (od 8 do 64) i znakiem. Typy rzeczywiste to Single, Double, Extended, Double, Real i Currency. Ada ma zaimplementowany mechanizm tworzenia typów całkowitoliczbowych i rzeczywistych poprzez podanie dziedziny, liczby bitów, itd. Predefiniowane są dwa typy root_integer i root_real, które są typami bazowymi dla wszystkich innych typów całkowitoliczbowych i rzeczywistych. Np.: PRZYKŁAD 3.3 type My_Integer is range -20_ _000; 31

33 MI: My_Integer; MIB: My_Integer'Base; type My_Float is digits 7; type Your_Float is digits 7 range -1.0E E+20; Mamy tu do czynienia z dwoma typami całkowitymi. Zmienne typu My_Integer mogą przyjmować wartości z przedziału do zaś zmienne typu My_Integer Base zajmują szesnaście bitów, stąd ich dziedzina to Typy rzeczywiste to My_Float i Your_Float. Oba przechowują liczby rzeczywiste z dokładnością do siedmiu cyfr po przecinku, różnią się tym, że podczas kompilacji i później podczas działania programu sprawdzany jest zakres dla zmiennych typu Your_Float. Object Pascal dla Delphi 5.0 zawiera tylko jeden typ znakowy, Jest to Char. Zmienne typu Char reprezentują jednobajtowe znaki ANSI. Ada oprócz typu Character (odpowiednik Char z Object Pascala) oferuje typ Wide_Character, który reprezentuje znaki Unicode Typy strukturalne Najprostszym typem złożonym w Object Pascalu jest zbiór (typ set of), który stanowi kolekcję elementów określonego typu porządkowego. Liczba elementów zbioru nie może przekraczać 256. Zdefiniowano operacje na zbiorach: +, -, * oznaczają odpowiednio sumę, różnicę i iloczyn zbiorów =, <>, >= i <= oznaczają równość i zawieranie się zbiorów Typ ten jest reliktem, pozostałym po dawnych wersjach Pascala, tym niemniej wciąż znajduje zastosowanie. Ada nie posiada konstrukcji set of. Istnieje co prawda odpowiednik rozwiązanie oparte na zastosowaniu wektorów typu boolean, związanych z danym typem porządkowym, ale jest ono rzadko stosowane i nie zaimplementowane w translatorze D2A. 32

34 Kolejnym typem złożonym jest tablica. Tablica to uporządkowany zbiór elementów danego typu. Konstruuje się ją za pomocą słowa kluczowego array. Implementacja tablic jest podobna w obu językach. Np.: PRZYKŁAD 3.4 Delphi: type Int_Arr = array [1..100] of Integer; //wektor 100 liczb integer Int_Arr2 = array [1..100, ] of Integer; //macierz Ada 95: type Int_Arr is array(1..100) of Integer; --wektor 100 liczb integer Int_Arr2 is array(1..100, ) of Integer; -- macierz Jeszcze jednym wspólnym dla obu języków typem strukturalnym jest rekord (record). Rekordy to kolekcje elementów różnych typów, poszczególne elementy są nazywane polami. Pola rekordu dostępne są poprzez odwołania kwalifikowane (nazwa zmiennej typu rekordowego, po niej kropka i nazwa danego pola). Rekordy mogą mieć tzw. warianty. W zależności od selektora niektóre pola mogą wystąpić w rekordzie lub nie. Oto przykład rekordu w Object Pascalu: PRZYKŁAD 3.5 type rec = record pole1: Integer; case selektor: Integer of //w tej części wybór wariantów 0: (pole1: Boolean;); 1: (pole2: String;); 33

35 end; Szczegółowe różnice pomiędzy implementacją tablic i rekordów w obu językach w kontekście translacji z Delphi do Ady zostały ujęte w paragrafach i Typy wskaźnikowe Zmienna typu wskaźnikowego (wskaźnik) przechowuje adres innej zmiennej danego typu. Np.: PRZYKŁAD 3.6 Delphi: type PInteger = ^Integer; var int: Integer = 3; p_integer: PInteger Ada 95: type PInteger = access Integer; int: aliased Integer := 3; p_integer: PInteger := int access; Podstawowa różnica pomiędzy implementacją wskaźników w obu językach polega na dużo większej restrykcyjności Ady. Na przykład zmienna, na którą wskazuje wskaźnik musi być zadeklarowana ze słowem kluczowym aliased Typy proceduralne 34

36 Typem proceduralnym w Object Pascalu jest wskaźnik do podprogramu. Przyczyną, dla której istnieje osobna klasyfikacja w Delphi dla tych typów jest zapewne nieco inny sposób definiowania wskaźników do podprogramów. W Adzie typ proceduralny to inaczej access to subprogram. PRZYKŁAD 3.7 Delphi: var f: procedure(i :integer); procedure proc(i:integer); f:=proc; f(2); //równoważne z wywołaniem proc(2) Ada 95: type a_proc is access procedure(i :integer); f: a_proc; procedure proc(i:integer); f:=proc; f(2); --równoważne z wywołaniem proc(2) 3.5 Programowanie obiektowe (OOP) Ponieważ oryginalny Pascal nie dawał możliwości programowania obiektowego, jego następcy: Object Pascal i Ada musiały wypracować własne konstrukcje służące temu. Stąd zupełnie odmienne podejście do tego tematu. Twórcy Object Pascala zdecydowali się na stworzenie architektury przypominającej C++ czy Javę. Ada 95 jest oparta bezpośrednio na strukturalnej Adzie 83, co w pewnym sensie ograniczyło możliwości języka w sensie syntaktycznym, tym niemniej udało się zachować funkcjonalność OOP. Wszystkie różnice pomiędzy oboma językami na tym polu opisuje i objaśnia rozdział czwarty (paragrafy: ). 35

37 3.6 Podsumowanie Podsumowując, Ada jest językiem bardziej skomplikowanym, za to dającym programiście dużo większe możliwości w konstruowaniu aplikacji niż Object Pascal. W powyższej analizie pominąłem te aspekty języka Ada 95, które są właściwie nieobecne w Object Pascalu (między innymi wbudowane w język konstrukcje służące do programowania współbieżnego). Większe bogactwo języka Ada jest korzystne z punktu widzenia programu translacyjnego. Dla prawie każdej konstrukcji w Delphi istnieje odpowiednik w Adzie. 36

38 4. Budowa i działanie programu D2A 4.1 Struktura programu D2A Podstawowym narzędziem translatora jest program D2A dokonujący translacji pojedynczego pliku zapisanego w języku Delphi na plik Ady 95. Program składa się z: - analizatora leksykalnego - modułu wczytującego tekst programu w języku źródłowym (Delphi) oraz dzielącego ten tekst na podstawowe symbole terminalne (tokens). - modułu translacyjnego modułu dokonującego rozbioru ciągu wejściowych symboli i tłumaczącego go na język docelowy (Ada 95). - modułu drzewa syntaktycznego służącego jako struktura pomocnicza dla modułu translacyjnego. - modułu wyjściowego pełniącego funkcje edytora składającego ciąg symboli wyjściowych i komentarzy translatora oraz zapisujących je do pliku docelowego (Ada 95). drzewo syntaktyczne plik źródłowy analizator leksykalny moduł translacyjny bufor wyjściowy plik docelowy Szkieletem programu D2A jest analizator gramatyki języka Object Pascal rozbudowywanego przez firmę Borland pod nazwą Delphi. Analizator został oparty na definicji języka zawartej w dokumentacji do pakietu Borland Delphi 5 przekształconej w notację EBNF [zał. B]. 37

39 Każdą definicję symbolu nieterminalnego przekształcono na podprogram analizujący dany symbol zgodnie z regułami B1-B6 par 4 roz. 1. Drugim, pomocniczym narzędziem jest program D2Amake, który służy do translacji danego pliku oraz innych plików, od których jest on zależny. Uruchomienie programu odbywa się z linii poleceń. Jeśli wywołamy program bez parametrów, na ekranie pojawi się następujący komunikat: usage: d2a [<options>] <input_file> [<preproc_file>] where options are: -p preprocess only (do not translate) -c include source as comment -t NUM tab spacing -mp PREFIX use PREFIX as method prefix -tp PREFIX use PREFIX as temp name prefix -cp PREFIX use PREFIX as constructor prefix -ap PREFIX use PREFIX as access of class prefix -ac PREFIX use PREFIX as access'class of class prefix -ci PREFIX use PREFIX as translator comment prefix -cn NAME use NAME as class parameter name Program za podstawowy parametr przyjmuje nazwę pliku źródłowego zawierającego tekst w języku Delphi (zwyczajowe rozszerzenia to pas i dpr). Wynikiem działania programu są trzy pliki: plik z deklaracją modułu (rozszerzenie ads), plik z definicją modułu (rozszerzenie adb) oba zawierające tekst przetłumaczony oraz plik zawierający publiczne typy, zmienne i stałe zdefiniowane w części interface pliku wejściowego (rozszerzenie ppc). Znaczenie poszczególnych parametrów jest opisane w poniższej tabeli: 38

40 parametr znaczenie wart. domyślna -p Program nie tłumaczy tekstu Delphi, generuje jedynie plik pcc z - typami, zmiennymi i stałymi zadeklarowanymi w części interface pliku wejściowego. -c Do plików wynikowych dołączany jest tekst programu Delphi w - formie komentarzy. -t NUM Program formatuje tekst wyjściowy. Ta opcja określa ilość spacji 4 przypadających na jedno wcięcie. -mp PREFIX Określa prefiks dla metod klas d2a_method -tp PREFIX Określa prefiks dla nazw tymczasowych (dla zmiennych, czy typów d2a_tmp pomocniczych) -cp PREFIX Określa prefiks dla konstruktora klasy d2a_constructor -ap PREFIX D2A definiuje dla każdej klasy typ będący wskaźnikiem do niej. d2a_access Nazwa tego typu to konkatenacja prefiksu PREFIX i nazwy klasy (łącznikiem jest znak podkreślenia). -ac PREFIX Jw., wskaźnik typu access class d2a_access_class -ci PREFIX Prefiks definiuje łańcuch znaków jaki pojawia się na początku każdej ++d2a++ linii komentarza generowanego przez D2A (aby odróżnić od komentarzy użytkownika) -cn NAME Nazwa parametru klasy dla metod. d2a_object 4.2 Działanie programu D2A Translacja struktur obiektowych Podejście do programowania zorientowanego obiektowo (OOP) stanowi jedną z bardziej istotnych różnic pomiędzy Delphi i Adą 95. Począwszy od różnic na poziomie składniowym, poprzez odmienne podejście do enkapsulacji (hermatyzacji), polimorfizmu czy dziedziczenia a skończywszy 39

41 na takich elementach Delphi, które nie istnieją w Adzie, można uznać to zagadnienie za najpoważniejszy problem postawiony przed translatorem. Typy class z Delphi tłumaczony jest na typ tagged record. Tagged record ma zaimplementowane dziedziczenie jednobazowe i polimorfizm Enkapsulacja Enkapsulacja jest zbędna, gdyż jest ona w swej istocie jedynie zabezpieczeniem przed niedozwolonym użyciem składowych danego typu klasowego (prywatnych pól i metod). Wychodząc z założenia, że tekst wejściowy (w Delphi) jest poprawny, wiadomo, że reguły enkapsulacji są w nim spełnione, a zatem będą także spełnione w tekście wyjściowym, pomimo że nie pola zmiennej typu tagged record nie będą zabezpieczone przed niepowołanym dostępem. Jedynym nasuwającym się zagrożeniem dla pominięcia dyrektyw określających widoczność (public, private) jest fakt, że programista może zechcieć rozwijać kod już przetłumaczony przez translator. Wtedy kompilator Ady nie będzie wstanie zweryfikować czy dane pole/metoda jest prywatne czy też publiczne. Translator w miejsce dyrektyw określających widoczność wstawia odpowiedni komentarz: --d2a: public --d2a: private zatem programista jest wstanie określić widoczność składowych używanej klasy Metody Specyfiką Ady 95 jest definiowanie metod (procedur lub funkcji) dla klasy (tagged record) poza jej blokiem, w przeciwieństwie do innych języków obiektowych, takich jak C++, Java oraz Delphi, gdzie metody definiowane (a przynajmniej deklarowane) są identycznie jak pola (zmienne). Różnice podejścia oraz konsekwencje zeń wynikające zilustruję na poniższym przykładzie: PRZYKŁAD 4.2a Delphi: type KLASA = class 40

42 end; a,b,c: integer; procedure PROC(x,y,z: integer); implementation procedure KLASA.PROC(x,y,z: integer); begin a:=x; b:=y; c:=z; end; var KLASA_VAR: KLASA; KLASA_VAR.PROC(1,2,3); PRZYKŁAD 4.2b Ada 95: type KLASA is tagged record a,b,c: integer; end record; procedure PROC ( obj: KLASA class; x,y,z:integer ) is begin obj.a:=x; obj.b:=y; obj.c:=z; end PROC_KLASA; 41

43 KLASA_VAR: KLASA; PROC(KLASA_VAR,1,2,3); W przykładzie zdefiniowano klasę KLASA w Delphi oraz jej odpowiednik w Ada 95. Klasa ta zawiera trzy pola typu integer (a,b,c) oraz jedną procedurę PROC, która przypisuje każdej z tych zmiennych pewną wartość (określoną odp. przez jej parametry). Jest ona deklarowana wewnątrz klasy, zaś jej definicja znajduje się w części implementacyjnej pliku Delphi. Procedura w przykładzie 2b jest zadeklarowana i zdefiniowana poza ciałem klasy, jej pierwszym parametrem jest zmienna reprezentująca daną klasę. Z takiego podejścia wynika kilka istotnych różnic w kodzie wykorzystującym wywołanie metod klas. w Delphi w ciele procedury PROC pola klasy są traktowane jak zmienne lokalne, odwołuje się do nich podając ich nazwy bez kwalifikatorów dostępu. w Adzie dostęp do wszystkich pól zdefiniowanych dla danej klasy odbywa się za pośrednictwem pierwszego parametru metody. Zatem linia a:=x; zostaje przetłumaczone na obj.a:=x; Analogiczne podejście obowiązuje dla wywoływania innych metod danej klasy. w Delphi odwołuje się do metod danej klasy z poza klasy tak jak do pól, czyli poprzedzając nazwę metody nazwą zmiennej typu danej klasy i kropką, np. KLASA_VAR.PROC(1,2,3); W Adzie taki napis należy zmienić na PROC(KLASA_VAR,1,2,3); Dziedziczenie 42

44 Zarówno w Delphi jak i w Adzie 95 obowiązuje model dziedziczenia jednobazowego tzn. dla danej klasy może istnieć tylko jeden przodek. Problem pojawia się gdy klasa Delphi implementuje jeden lub więcej interfejsów [5] (deklaracja implementacji test technicznie identyczna do zadeklarowania dziedziczenia). Ada nie obsługuje interfejsów w składni języka zatem nie istnieje możliwość translacji. W przypadku, gdy translator natknie się na wielokrotne dziedziczenie/implementację przyjmie, że klasą bazową jest pierwszy identyfikator z listy identyfikatorów w deklaracji dziedziczenia/implementacji a następnie wstawi w kod odp. ostrzeżenie: --d2a: warning: multiple inheritance not implemented Każda klasa Delphi pochodzi (pośrednio bądź nie) od klasy TObject. Stworzono plik base.ads, w którym zdefiniowano specjalną klasę o nazwie Object, która jest klasą bazową dla wszystkich klas przetłumaczonych z Delphi. Pochodzi ona od klasy Controlled. Zawiera odpowiednie procedury wywoływane przy tworzeniu i niszczeniu obiektów Polimorfizm Podejście do polimorfizmu jest w obu językach odmienne. W Delphi przyjęto model zbliżony do Javy, czyli każda zmienna reprezentująca klasę jest niejawnie referencją [8] bądź wskaźnikiem do niej. Obiekty różnych klas mogą posiadać metody o identycznych nazwach, ale innym działaniu. Na etapie kompilacji nie zawsze wiadomo, jaki typ (klasę) reprezentuje dany obiekt (pamiętajmy jest to w istocie referencja do obiektu). Może to być typ wynikający z deklaracji tegoż obiektu, można jednak przypisywać do niego inny obiekt, typu dowolnej klasy pochodnej względem klasy zadeklarowanej. Metody, które podlegają mechanizmowi polimorfizmu wirtualne deklarowane są z dyrektywą virtual w klasie bazowej oraz override w klasach pochodnych (w tych, w których chcemy skorzystać z polimorfizmu). Zastosowanie polimorfizmu ilustruje poniższy przykład: PRZYKŁAD 4.3 type T_X=class a:integer; function fun:boolean; virtual; 43

45 end; constructor Create( x:integer ); T_Y=class(T_X) //tu dziedziczenie po klasie T_X b:integer; function fun:boolean; override; constructor Create( x,y:integer ); end; implementation T_X.fun:boolean; begin return false; end; T_Y.fun:boolean; begin return true; end; var zmienna:t_x; bool:boolean; zmienna:=t_x.create(1); //zmienna ma typ T_X bool:=zmienna.fun; //zmiennej bool zostanie przyp. wart. false zmienna:=t_y.create(1,2); //zmienna ma typ T_Y bool:=zmienna.fun; //zmiennej bool zostanie przyp. wart. true 44