Ada/Tutorial
Aus StudiWiki
Inhaltsverzeichnis |
[bearbeiten] Hello World
Das obligatorische erste Beispiel zu einer Programmiersprache :)
with ada.text_io;
use ada.text_io;
procedure helloworld is
begin
put_line("hello world");
end helloworld;
Und jetzt gehen wir Zeile für Zeile durch:
with ada.text_io; use ada.text_io;
Mit diesen zwei Zeilen hat man das Paket text_io eingebunden, welches unter anderem die Methoden put und get ermöglicht. Mehr dazu unter AdaStandardPackages
procedure helloworld is begin ... end helloworld;
Damit begint jedes Ada Programm. "helloworld" ist der Name dieses Programms und kann beliebig verändert werden. Aber wenn man das erste helloworld verändert, muss man auch das helloworld am Ende entsprechend verändern. Der Dateiname sollte auch gleich sein (muss aber nicht).
put_line("hello world");
Die Zeile ist für die Ausgabe auf der Konsole verantwortlich. Beachte, dass man diese Methode nur benutzen kann wenn man das text_io Paket einbindet.
Das wars fürs erste. Tipp die Zeilen ab und compiliere das Programm. Spiel damit rum, probier etwas zu verändern und schau wie der Compiler drauf reagiert.
[bearbeiten] Installation
[bearbeiten] Unter Linux
Für die Installation von GNAT unter Linux gibt es 2 Möglichkeiten, entweder die klassische(selbst herunterladen und installieren), oder, sofern verfügbar, der package manager(das ich empfehle). Unter Ubuntu sieht das dann folgender maßen aus:
sudo apt-get install gnat-4.1
Für die aktuelle Version. Alerternativ gibt es auch folgenden Weg:
- Als erstes GNAT ziehen: https://libre.adacore.com/ (Download GNAT, Finger weg von der Eclipse Version)!
- Dann auf die Konsole gehen und in das Verzeichnis wechseln, in dem die Datei liegt und die Datei entpacken
tar -xf gnat-gpl-2007-i686-gnu-linux-libc2.3-bin.tar.gz (In meinem Fall)
- In das neue Verzeichnis wechseln:
cd gnat-2007-i686-gnu-linux-libc2.3-bin/ (In meinem Fall)
- Hier liegt die "doinstall", sie muss mit root-Rechten ausgeführt werden, unter Ubuntu :
sudo ./doinstall
- Jeder, der ein bisschen Englisch versteht, kann sich vom Installer führen lassen.
- Zum Ende der Installation noch(wie der Installer einem mitteilt) den Pfad der neuen Installation in die Umgebungsvariable packen:
PATH=<Installationspfad>/bin:$PATH; export PATH
Nun brauchen wir noch einen Editor. vim und emacs Fans jetzt bitte wegscrollen ;-) Ich dachte zuerst an Eclipse, zumal es einige entsprechende Plug-Ins gibt, ich hab es jedoch noch nicht zum laufen gebracht. Wenns einer schafft, bitte diesen Artikel erweitern! Ich habe dann ScITE mal probiert(wie empfohlen), favorisiere aber inzwischen Komodo: Hat alles bis auf Auto-Vervollständigung! Wichtig ist, Komodo Edit zu nehemn, nicht die kostenpflichtige IDE...
Ihr bekommt es hier: http://www.activestate.com/Products/komodo_edit/
- Alltbekanntes Prozedere:
- Entpacken und in den Ordner wechseln
tar -xf Komodo-Edit-4.2.1-283000-linux-libcpp5-x86.tar.gz cd Komodo-Edit-4.2.1-283000-linux-libcpp5-x86/
- Und den Installer machen lassen. Wie bei GNAT braucht ihr root-Rechte, wenn ihr die Installation nicht unbedingt im home-Verzeichnis haben wollt.
- Dann noch die Umgebungsvariable schreiben
PATH=<Installationspfad>/bin:$PATH; export PATH
- Und fertig, ausführbar via "komodo"
Nun müssen wir den frisch installierten Editor noch ein bisschen auf ADA einrichten:
- Komodo starten
- Über Edit -> Preferences -> File Associations die Datei-Endungen *.adb und *.ads Ada zuweisen
Dann, um per Knopfdruck compilieren und ausführen zu können:
- Über View -> Tabs -> Toolbox die Toolbox anzeigen lassen
- In der Toolbox ist links oben ein kleines Icon ("Add Item to Toolbox")...Klick!
- New Command auswählen
- "Run" oder dergleiches als Namen eintragen(ist nicht weiter wichtig)
- Bei Command folgendes eintragen: ./%b (%b wird durch den Dateinamen ohne Endung ersetzt)
- Im Feld "Start in" noch "%D" eintragen(wird durch das Verzeichnis der Datei ersetzt).
- Im Reiter "Key Bindings" könnt ihr dann noch einen Hotkey zuweisen.
- Die "Compilier-Funktion" geht dann gleichmaßen einzubauen:
- New Command auswählen
- "Compile" oder dergleiches als Namen eintragen(ist nicht weiter wichtig)
- Bei Command folgendes eintragen: gnatmake %f (%f wird durch den Dateinamen ersetzt)
- Im Feld "Start in" noch "%D" eintragen(wird durch das Verzeichnis der Datei ersetzt).
- Im Reiter "Key Bindings" könnt ihr dann noch einen Hotkey zuweisen.
[bearbeiten] Unter Windows
Die folgende Kurzanleitung gilt nur für AdaGide. Alternativ kann auch das bei GNAT mitgelieferte GPS verwendet werden. In diesem Fall einfach den Schritt AdaGide installieren weglassen :)
- Zunächst AdaGide, GNAT und GNAT Win32 Bindings herunterladen.
- AdaGide: http://sourceforge.net/projects/adagide/
- GNAT: https://libre2.adacore.com/ (Benötigt: gnat-gpl-2006-1-pentium-mingw32msv-bin.exe und win32ada-gpl-2006-1.exe)
- GNAT installieren (dauert ewig)
- Die GNAT Win32 Bindings installieren (den eben installierten Compiler zum integrieren auswählen, falls nicht automatisch korrekt)
- AdaGide installieren
[bearbeiten] Kompilieren
[bearbeiten] Unter Linux
* Mach eine Konsole auf
* Wechsle in das Verzeichnis, in dem sich deine .adb-Datei befindet
* Führe {{{gnatmake helloworld.adb}}} aus ({{{.adb}}} kann dabei weggelassen werden).
* Ausführen des Programms: {{{./helloworld}}}
[bearbeiten] Unter Windows
* Benutze AdaGide oder * Wenn du einen Gnat-Compiler für Windows installiert hast, kannst du ähnlich wie unter Linux in der Eingabeaufforderung verfahren
Siehe auch Ada/Compiler Messages
[bearbeiten] Unter Mac OS X
* Ausführung des Kompilers wie unter Linux * Den Compiler gibt es auf http://www.adapower.net/macos/compiler.html
[bearbeiten] Variablen
Variablen sehen in Ada etwas anders aus, als in anderen Programmiersprachen(z.B. Java), aufgrund der strikten Trennung zwischen Deklarations- und Funktions-Block. Nun, der erste Teil, den wir brauchen, die Deklaration. Sie erinnert an UML-Notation:
<Name> : <Type> (<Parameter>);
also z.B.
Container : String (1..5);
Als Parameter können nur Werte oder Variablen verwendet werden. Ein Funktionsaufruf, um möglicherweise einen Wert erst zu erhalten, ist nicht möglich.
Der zweite Teil ist die Initialisierung, sie sich an der typischen mathematischen Notation orientiert. Dieser Teil ist, so "stand-alone", nur im Funktions-Block zulässig.
<Name> := <Wert>;
also z.B.
Container := "Hallo";
oder
Container := Get_Text ("Hello");
Wobei hier der Wert eben ein statischer Wert, eine Variable oder ein Funktionsaufruf sein kann.
Alternative kann - gerade für Konstanten interessant - der Variable auch bei der Deklaration ein Wert zu gewiesen werden. Natürlich nur im Deklarations-Block.
ASCII_A_OFFSET : constant Integer := Character'Val ("A");
Funktionsaurufe sind an dieser Stelle natürlich immernoch unzulässig und das "constant" ist hier optional, jedoch in dem Fall sinnvoll.
[bearbeiten] Zufallszahlen
Ein einfaches Beispiel für einen Zufallsgenerator, der ganze Zahlen zwischen 1 und 10 erzeugt und auf der Konsole ausgibt.
with ada.text_io;
use ada.text_io;
with ada.integer_text_io;
use ada.integer_text_io;
with ada.numerics.discrete_random;
procedure random is
subtype rand_range is integer range 1..10;
package rand is new ada.numerics.discrete_random(rand_range);
use rand;
gen : generator;
begin
reset(gen);
loop
put(random(gen));
new_line;
end loop;
end random;
kurze Beschreibung:
with ada.numerics.discrete_random;
Dieses Paket stellt unter anderem die Funktion random bereit.
subtype rand_range is integer range 1..10;
Hiermit legen wir fest dass die Zufallszahl zwischen 1 und 10 liegen soll.
package rand is new ada.numerics.discrete_random(rand_range); use rand;
Jetzt wird ein package rand mit dem soeben angelegte Zahlenbereich rand_range erzeugt.
gen : generator;
ein Zufallszahlen Generator
reset(gen);
Damit wird ein neuer Startwert erzeugt. Ansonsten erhält man bei jeden Programm Aufruf wieder dieselben Zufallszahlen.
loop put(random(gen)); new_line; end loop;
Eine Endlosschleife. random(gen) ist die eigentliche Funktion, die die Zufallszahl generiert.
