Handbuch

PscIDE

Autor: Thomas Zauner, FH Hagenberg 09 Seite 1

Inhaltsverzeichnis
Einleitung ...........................................................................................................................................3
Anforderungen ...................................................................................................................................3
Installation..........................................................................................................................................4
Bedienung ..........................................................................................................................................5
Anhang – Grammatik Regeln...............................................................................................................9

Autor: Thomas Zauner, FH Hagenberg 09 Seite 2

Einleitung
Die Entwicklung der Entwicklungsumgebung PscIDE entstand im Rahmen des Master Studiums
Software Engineering des Autors an der Fachhochschule Hagenberg. Gemeinsam mit der
Masterprüfung bilden diese Entwicklung und die dazugehörige Diplomarbeit den Grundstein für den
positiven Abschluss des Studiums.

Die Diplomarbeit ist eine Erweiterung des Buchs Algorithmen und Datenstrukturen (H. Dobler, G.
Pomberger, Pearson Studium 2008). In diesem Buch beschreiben die Autoren Dobler und Pomberger
Methoden der Programmierung und verwenden dafür einen speziellen Pseudocode. Da der Pseudo-
code nicht direkt ausführbar ist, ist das Testen der angeführten Pseudocode-Beispiele umständlich.
Deshalb kam der Wunsch nach einer Entwicklungsumgebung für diesen Pseudocode auf.

Das Ziel der Diplomarbeit war es, diese Entwicklungsumgebung zu konzipieren und zu implement-
ieren. Mit Hilfe der neu entstandenen Entwicklungsumgebung kann der Pseudocode automatisch
überprüft und in echte Programmiersprachen übersetzt werden. Die aktuelle Version unterstützt die
Umwandlung in die Programmiersprachen C++ und Pascal.

Die Entwicklungsumgebung wurde mit dem Framework Eclipse Rich Client Platform (RCP) entwickelt.
Der Compiler für den Pseudocode wurde mit dem Werkzeug javacc realisiert. Für weitere Details der
Implementierung sei auf die Diplomarbeit Algorithmen-Entwicklungssystem für Pseudocode (T.
Zauner, FH Hagenberg 2009) verwiesen.

Dieses Dokument gibt einen kurzen Einblick über die Installation und Benutzung der entstandenen
Entwicklungsumgebung PscIDE. Die Abkürzung PscIDE steht für Pseudocode integrated development
environment, also eine integrierte Entwicklungsumgebung für Pseudocode.

Anforderungen
Folgende Anforderungen sind nötig, damit PscIDE verwendet werden kann:

BETRIEBSSYSTEM: Microsoft Windows XP, Microsoft Windows Vista oder

Microsoft Windows 7 (jeweils Administratorrechte erforderlich)

EINGABEGERÄTE: Tastatur und Maus

ZUSÄTZLICHE SOFTWARE: Aktuelles Java Runtime Environment (Stand Sept09: V6u16)

Für das Umwandeln in ausführbare Programme werden zusätzlich

sowohl ein Compiler für Pascal als auch für C++ benötigt. Die
Implementierung ist optimiert auf die Compiler FreePascal und
Mingw.

Autor: Thomas Zauner, FH Hagenberg 09 Seite 3

Installation
(1) Die Entwicklungsumgebung PscIDE ist als komprimierte RAR-Datei erhältlich. Diese Datei
muss zunächst geöffnet und der Inhalt auf die Festplatte kopiert werden (zB. mit WinRAR).

(2) Der Ordner PscIDE hat folgende Struktur:

(3) Für das Starten der Entwicklungsumgebung PscIDE wird ein aktuelles Java Runtime Environ-
ment benötigt. Dieses kann unter http://www.java.com/de/download/ heruntergeladen und
anschließend installiert werden. Im September 09 war die Version 6 Update 16 als aktuellste
erhältlich. Die durchgeführten Tests mit dieser Version waren erfolgreich.

(4) Für das Übersetzen und Ausführen in echte Programmiersprachen werden noch zusätzliche
Compiler benötigt. Die Entwicklungsumgebung PscIDE ist auf die Compiler FreePascal (Pas-
cal) und Mingw (C++) optimiert. Installieren Sie diese Compiler auf Ihrem Computer.

FreePascal findet man unter http://www.freepascal.org.

Mingw ist unter anderem bei der Entwicklungsumgebung Dev-Cpp inkludiert
http://www.bloodshed.net/devcpp.html, kann aber auch als unabhängige Anwendung
heruntergeladen und installiert werden http://www.mingw.org/.

Autor: Thomas Zauner, FH Hagenberg 09 Seite 4

Bedienung
Erstes Starten
Die Entwicklungsumgebung PscIDE wird mit einem Doppelklick auf PscIDE.exe gestartet. Nach dem
Starten bietet sich in etwa folgendes Bild:

Vor dem Testen des ersten Programms müssen die bereits installierten Compiler für Pascal und C++
eingebunden werden. Das Einbinden erfolgt mit den Compiler-Optionen-Dialogen (Options – Pascal/
C++ Compiler Options). Dort müssen die ausführbaren Dateien der Compiler ausgewählt werden (zB.
bei Freepascal fpc.exe, bei GCC c++.exe). Bei Standardinstallation von FreePascal und Mingw sehen
die Pfade wie folgt aus:

Autor: Thomas Zauner, FH Hagenberg 09 Seite 5

Nach erfolgreichem Einrichten kann das erste Pseudocode-Programm geöffnet und anschließend
ausgeführt werden. Öffnen Sie dazu mit File – Open File die Datei hello.psc. Die Datei befindet sich im
Installationsordner der Entwicklungsumgebung PscIDE im Ordner examples.

Anschließend kann dieser Code compiliert, in Pascal oder C++ übersetzt und zusätzlich noch ausge-
führt werden.
Compile – Compile (.pas): Übersetzt den Code in Pascal-Code.
Compile – Compile+Run (.pas): Übersetzt den Code in Pascal-Code und führt in anschließend aus.
Compile – Compile (.cpp): Übersetzt den Code in C++-Code.
Compile – Compile+Run (.cpp): Übersetzt den Code in C++-Code und führt in anschließend aus.

Alle erzeugten Dateien (.pas, .cpp und .exe) sind im gleichen Ordner, wie die Eingabedatei (.psc).
Testen Sie sowohl die Erzeugung und Ausführung nach Pascal und C++. Sehen Sie sich auch die er-
zeugten Codedateien an.

Wird das Programm hello.psc ausgeführt, wird zusätzlich noch eine Windows-Konsole gestartet und
das Programm dort ausgeführt:

Autor: Thomas Zauner, FH Hagenberg 09 Seite 6

Erweiterte Bedienung
Die Entwicklungsumgebung PscIDE bietet eine interaktive Hilfe in Form von Cheatsheets (Help –
Cheatsheets…). Dort gibt es eine kurze Einführung in die ersten Schritte. Wählen Sie das Tutorial
Getting started aus.

Cheatsheets werden interaktiv in die Anwendung eingebunden. Mit Ihrer Hilfe soll sich der Benutzer
eingehender mit dem System beschäftigen und sich die Hände am System schmutzig machen.

Autor: Thomas Zauner, FH Hagenberg 09 Seite 7

Die Editoren der Pseudocode-Programme bieten die Möglichkeit, diverse Optionen einzustellen (zB.
Zeilennummern, Einrückung, …). Die Optionen des Editors können mit einem Rechtsklick auf den Edi-
tor unter Preferences… geändert werden.

Im Ordner examples finden sich noch weitere Beispiele für Pseudocode-Programme. Öffnen Sie diese
und machen Sie sich mit der Syntax des Pseudocodes vertraut. Zusätzlich finden Sie im Anhang noch
Grammatik Regeln, welche den Aufbau der Pseudocode-Programme beschreiben.

Abschließend folgt noch die Beschreibung der einzelnen Pseudocode-Programme:

calculateAverage.psc: liest x-Werte ein und berechnet daraus Mittelwert.

compounds.psc: zeigt die Syntax und Verwendung von Strukturen.
division.psc: Beispiel für eine Division mit Rest.
divTests.psc: einige Tests, welche die Syntax des Pseudocodes zeigen.
divTestsExt.psc: weitere Tests der Syntax, zB. Strukturen.
error.psc: erzeugt einen Fehler, zum Testen der Ausgabeansicht und der Fehleransicht.
hello.psc: Hello World-Programm.
intpointer.psc: Testprogramm mit Zeigeroperationen.
io.psc: Ein-/Ausgabe-Programm.
list.psc: Methoden zum Erstellen einer Liste.
minMax.psc: liest zwei Werte ein und liefert Minimum/Maximum.
schleifen.psc: Beispiele für Schleifen.
simpleMult.psc: Beispiel einer einfachen Multiplikation.
warnings.psc: erzeugt Warnungen, zum Testen der Ausgabeansicht und der Fehleransicht.

Autor: Thomas Zauner, FH Hagenberg 09 Seite 8

Anhang – Grammatik Regeln
Dieser Anhang zeigt den Aufbau der Pseudocode-Programme anhand von Grammatik Regeln.

1 Start :
2 Program .
3
4 Program :
5 "program" Identifier
6 (ConstDecl | TypeDecl | VarDecl | FuncDef)*
7 Block .
8
9 ConstDecl :
10 "const" Identifier "=" (Integer|Floating) [";"] .
11
12 TypeDecl :
13 "type" (TypeSpecification)+ .
14
15 TypeSpecification :
16 Identifier "=" [Pointer] (Type|ArrayType|CompoundType) [";"] .
17
18 VarDecl :
19 "var" (VarSpecification)+ .
20
21 VarSpecification :
22 IdentifierList ":" [Pointer] (Type|ArrayType|CompoundType) [";"] .
23
24 Type :
25 ("int" | "bool" | "real" | "char" | "string" | Identifier) .
26
27 ArrayType :
28 "array" "[" ArraySpec (","ArraySpec)* "]" "of" Type .
29
30 ArraySpec :
31 (Integer|Identifier) ":" [(Integer|Identifier)] .
32
33 CompoundType :
34 "compound" (CompoundSpecification)+ "end" .
35
36 CompoundSpecification :
37 IdentifierList ":" [Pointer] (Type|ArrayType) [";"] .
38
39 Pointer :
40 "->" .
41
42 FuncDef :
43 FuncHead (VarDecl)* Block Identifier .
44
45 FuncHead :
46 Identifier "(" (FuncParList)* ")" [ ReturnType ] .
47
48 FuncParList :
49 ParameterType Identifier ":" [Pointer] (Type | ArrayType) .
50
51 ParameterType :
52 ("in" | "out" | "io") .
53
54 ReturnType :
55 ":" [Pointer] (Type | ArrayType) .

Autor: Thomas Zauner, FH Hagenberg 09 Seite 9

56
57 Block :
58 "begin" (Stat)* "end" .
59
60 Stat :
61 ( Text | AssignStat | CallStat | IfStat | WhileStat
62 | ForStat | RepeatStat | BreakStat | HaltStat
63 | InputStat | OutputStat | DeleteStat | ReturnStat | Block
64 ) [";"] .
65
66 Text :
67 "-!" String .
68
69 AssignStat :
70 LongIdentifier ":=" Expr .
71
72 CallStat :
73 Identifier "(" (ActParList)* ")" .
74
75 ActParList :
76 ParameterType Expr .
77
78 IfStat :
79 "if" Expr "then" (Stat)* [ElseBlock] "end" .
80
81 ElseBlock :
82 "else" (Stat)* .
83
84 WhileStat :
85 "while" Expr "do" (Stat)* "end" .
86
87 ForStat :
88 "for" Identifier ":=" Integer "to" Expr "do" (Stat)* "end" .
89
90 RepeatStat :
91 "repeat" (Stat)* "until" Expr .
92
93 BreakStat :
94 "break" .
95
96 HaltStat :
97 "halt" .
98
99 InputStat :
100 "Read" "(" ["out" LongIdentifier] ")" .
101
102 DeleteStat :
103 "Dispose" "(" "in" LongIdentifier ")" .
104
105 OutputStat :
106 "Write" "(" (SingleOutput)+ ")" .
107
108 SingleOutput :
109 "in" Expr .
110
111 ReturnStat :
112 "return" [ Expr ] .
113
114 Expr :
115 OrExpr .
116

Autor: Thomas Zauner, FH Hagenberg 09 Seite 10

117 OrExpr :
118 AndExpr ("or" AndExpr)* .
119
120 AndExpr :
121 RelExpr ("and" RelExpr)* .
122
123 RelExpr :
124 SimpleExpr
125 [ ("=" | "!=" | "<" | "<=" | ">" | ">=") SimpleExpr ] .
126
127 SimpleExpr :
128 [("+"|"-")] Term ( ("+"|"-") Term )* .
129
130 Term :
131 NotFact ( ("*"|"/"|"%") NotFact )* .
132
133 NotFact :
134 ["not"] Fact .
135
136 Fact :
137 ( CallStat | NewStat | AddrOfStat | NullFact
138 | Integer | Floating | LongIdentifier | NestedExpr
139 | String | Char | FalseFact | TrueFact ) .
140
141 FalseFact :
142 "false" .
143
144 TrueFact :
145 "true" .
146
147 NullFact :
148 "null" .
149
150 NewStat :
151 "New" "(" "in" Type ")" .
152
153 AddrOfStat :
154 "AddrOf" "(" "in" LongIdentifier ")" .
155
156 NestedExpr :
157 "(" Expr ")" .
158
159 LongIdentifier :
160 Identifier [ NextIdentifier ] [ "[" ExprList "]" [NextIdentifier] ] .
161
162 ExprList :
163 Expr ("," Expr)* .
164
165 NextIdentifier :
166 ( "->" [LongIdentifier]
167 | "." LongIdentifier ) .
168
169 IdentifierList :
170 Identifier ("," Identifier)* .

Autor: Thomas Zauner, FH Hagenberg 09 Seite 11