Einführung in die Programmiersprache ISOM/L
Werbung
Excellence in Automotive Computing. Informationstechnik München Handbuch Titel des Dokuments Einführung in die Programmiersprache ISOM/L Kurztitel Einführung ISOM/L Vorgang externe Referenz BZ-9758 [email protected] Das folgende Dokument ist geistiges und urheberrechtliches Eigentum der Name und Anschrift IFS Informationstechnik München Trausnitzstraße 8 81671 München Die IFS behält sich ausnahmslos alle urheberrechtlichen Ansprüche vor, welche sie gemäß der geltenden Rechtslage in der Bundesrepublik Deutschland sowie aus den jeweiligen Teilen des Werkes, für die die IFS aufgrund von erfinderischer Tätigkeit natürlicherweise die Urheberschaft besitzt, ableiten kann. Unbeeinflusst davon sind Rechte Dritter, für die die IFS, gemäß den mit diesen Dritten vereinbarten Verträgen und Überlassungen, das vorliegende Werk ggf. auch im Auftrag erstellt hat. Eine Abtretung der Urheberschaft kann daraus dennoch nicht abgeleitet werden. Autorin des Dokuments Alexander Noé Erstellungsdatum Datum der letzten Änderung 03. Dezember 2009 18. Juni 2013 Version des Dokuments 3.1 erfinden verbessern gewinnen • gemeinsam. IFS Informationstechnik GmbH Trausnitzstraße 8 81671 München Telefon +49 89 450983 0 Fax +49 89 450983 10 www.ifs-it.de Kreissparkasse München Konto 10 110 344 BLZ 702 501 50 Amtsgericht München HRB 126547 USt-IdNr: DE203067267 Geschäftsführer: Dr.-Ing. Markus A. Stulle Dipl.-Ing. Thomas Frey Excellence in Automotive Computing. Informationstechnik München Dokumentinformationen Status Bezeichnung freigegeben Dieses Dokument unterliegt einem systematischen Änderungsdienst. Personen und Rollen Personen Rollen Dr.-Ing. Markus A. Stulle Auftraggeber Dr. Tim-Oliver Paaschen Vorhabensverantwortlicher Roland Ott Qualitätsbeauftragter Christian Manhart Gutachter Dr. Mario Schweigler Gutachter Bettina von Staden Lektorin Speicherort des Dokuments Pfad \\ifshome.muc.smarttrust.de\IFS\Produkte\Taurus\02 Arbeitspakete\BZ-9758 (Aenderungsdienst Sprachbeschreibung ISOM-L)\06 Spezifikation\BZ-9758 Handbuch Einführung ISOML v3.1.doc 2 von 109 Dokumentinformationen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Inhalt 3 von 109 Inhalt 1 Einführung 7 1.1 Die Laufzeitumgebung für ISOM/L 7 1.2 Über dieses Dokument 7 2 Eine Einführung in ISOM/L 9 2.1 Hello, world 9 2.2 Hello, world – erweiterte Version 14 3 Kontrollstrukturen 18 3.1 Bedingte Codeausführung mit if/else 18 3.2 Bedingte Codeausführung mit switch/case/default 22 3.3 Schleifen 23 3.4 Abschließende Blöcke 25 4 Grundlagen des ISOM/L-Objektmodells 31 4.1 Objekte als grundlegendes Paradigma 31 4.2 Basisobjekte 32 4.3 Sonderbehandlung der Klassen Boolean und Number 33 4.4 Fachfunktionen statt Operatoren 34 4.5 Objektbasiert statt objektorientiert 35 4.6 Fachfunktionen von Objekten 39 4.7 Grundlegendes zum ISOM-Objektmodell 40 4.8 Das Void-Objekt 41 4.9 Containerklassen 46 4.10 Globale Variablen 50 4.11 ISOM/L-Bibliothek für Fachautoren 51 4.12 Erweiterung der Klassen des ISOM-Objektmodells 51 5 Strukturierung von ISOM/L-Programmen 54 5.1 Hierarchische Struktur von Namensräumen 56 5.2 Die Importanweisung 57 5.3 Übersetzbare Texte und Textdefinitionen 58 5.4 Einfügen von Dateien in ISOM/L-Quellen 60 6 Ein- und Ausgabe 61 Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 4 von 109 Inhalt 6.1 Standard-Datenströme 61 6.2 Dateizugriff 63 7 Bedienoberfläche und Benutzerinteraktion 67 7.1 Darstellung der Bedienoberfläche im Kommandozeilenmodus 68 7.2 Identifikationsnummern und Schlüssel 68 7.3 Bedienelemente 71 7.4 Auswertung von Benutzereingaben 73 7.5 Assistenten 76 8 Werkzeuge 87 8.1 Verwendung des Interpreters 87 8.2 Einzelschrittausführung im Kommandozeilenmodus 89 9 Syntaxgraphen von ISOM/L 91 9.1 Grundelemente der Syntax 92 9.2 Syntax der Konstanten und Bezeichner 93 9.3 Syntaktischer Aufbau einer ISOM/L-Datei 96 9.4 Syntax einer ISOM/L-Funktionsdeklaration 99 9.5 Syntax der ISOM/L-Anweisungen 100 9.6 Syntax der ISOM/L-Ausdrücke 104 Verzeichnisse und Anhänge 105 A Verzeichnis der Tabellen 105 B Verzeichnis der Abbildungen 105 C Verzeichnis der Codeauszüge 105 D Referenzen 107 E Anhang: Überblick über die Schlüsselwörter in ISOM/L 107 Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Index finally 25 Funktion 12, 36, 57 Funktionsdefinition 13, 36 # #include 60 A G Aliasing 33 Anweisung 11 Anzeigetexte 71 ASAM-MCD 7 Assistent 67 At 46 Ausdruck 18, 32 Ausnahme 41 Auswahlgruppen 71 GetAllEnvironmentVars 21 GetId 68 GetInstance 40 Globale Variable 50 Grundraumbezeichner 56, 58 -Gui 68 H HasNext 46 -Help 88 Hexadezimalzahlen B base 52 Basisobjekt 32 Bedingte Codeausführung Bedingung 18 Bezeichner 10 Block 11 Blockkommentar 11 Boolean 33 18 C case 23 Clone 34, 35 Containerobjekt continue 23 Create 40 46 D -Debug 88 default 23 deftext 17 Dialogfenster DisableBack() Dispose() 74 67 78 E Einzelschrittmodus Element 46 else 18 Equals 34 extension 51 89, 90 F Fabrikmethode 40 Fachfunktion 31 Failed 43 Fall-Anweisung 22 Fehlerbehandlung 41 5 von 109 Index 33 I if 18 if/else 18, 55 Import 14 Importanweisung (using) 15, 54, 55, 57, 58 Insert 46 instanzgebundene Fachfunktion 31 instanzlose Fachfunktion 31 ISO-8859-1 56 Isom.Base.Data 63 Isom.Base.Uri 63 Isom.Global.Processes 56 Isom.Request 67 Isom.Request.Wizard 76 Isom.Sys.System 61 ISOM/L 7 IsomInstance.exe 87 -IsomlCheckOnly 88 -IsomSession 88 Ist-Kontext 40 IsVoid() 41 K Kategorie 16 Klasse 31 Kommandozeilenmodus 54, 87, 89 Kommandozeilenparameter 88 Kommentar 11 L leave 26 Literal 32 LoadXml 66 Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München M main-Funktion 13, 54, 55, 87 -MaxRecursion 88 -MaxRuntime 88 Medienelement 71 Messwerte 71 Methode 31 N T Namensraum 12, 35–41 Namensraum, anonymer 60 namespace 12 Next 46 -NoLog 88 Number 33 NumberList 46 Taschenrechner 78 Textbezeichner 16 TextCategoryData.xml Textdefinition 58 this 51 Trennzeichen 11 Typ 32 Typbezeichner 36 O objectbound 51 Objekt 31 Objektinstanz 31 Objektmodell 35, 40 Operator 32, 34 Option 71 59 U übersetzbare Texte 58 Ungültig-Machen 41 UpdateMeasurement() 77 UpdateMessage() 77 UriDictionary 48 using (Importanweisung) 58 UTF-8 54 P Parameter-Variable 36 ParseNumber 19 Polymorphie 35 primitiver Datentyp 33 -Program 88 15, 54, 55, 57, V Variable 31 Vererbung 35 Void() 41 Void-Objekt 41, 43 vollqualifizierter Typname 58 R Referenztyp Reset 46 return 38 Run() 76 Stdin 19 Stdout 13 String 32 StringDictionary 21 switch 22 switch/case/default 22 Syntax 10 Syntaxgraph 91 33 15, 56, 57, S W Schaltfläche 71 Schleife 23 Schlüsselwort 107 Schrittsteuerung 76 Schrittsteuerung, manuelle SetUpdateFunction() 77 ShowRequest 73 Signatur 36 Singleton 40 Standardausgabe 13 Standardfall 23 Stderr 21 WaitUserRequest() 73 -Warnings 88 Werttyp 33 while 23 while/break/continue 23, 55, 90 Wörterbuch 48 WriteXml 65 6 von 109 Index 85 X XML-Format 64 Z Zeilenkommentar Zuweisung 11 11 Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 1 Einführung ISOM/L ist eine einfache und robuste Programmiersprache. Ihre Entwicklung wurde von den Serviceaufgaben bei der SoftwareReparatur von Fahrzeugsteuergeräten in der Werkstatt beeinflusst. Zur Software-Reparatur zählen zum Beispiel das Auslesen von Fehlerspeichereinträgen, die Programmierung und Codierung von Steuergeräten („Flashen“) und die Ermittlung des Fahrzeugauftrags. Die Durchführung dieser Serviceaufgaben basiert auf Standards wie ASAM-MCD. ISOM/L ist eine objektbasierte, interpretierte Programmiersprache, die zur Beschreibung von Serviceabläufen zur Ausführung durch ISOM verwendet wird. Die Sprache erlaubt die flexible Definition von Serviceabläufen und deren Steuerung durch das bereitgestellte ISOM-Objektmodell. 1.1 Die Laufzeitumgebung für ISOM/L Die Laufzeitumgebung von ISOM/L besteht aus dem ISOM-Interpreter zur Ausführung der ISOM/L-Programme. Sie stellt die Basistypen für ISOM/L zur Verfügung und überwacht die Ausführung der Programme. 1.2 Über dieses Dokument Das vorliegende Handbuch stellt die Sprache ISOM/L vor und bietet eine Einführung in die Verwendung von ISOM/L anhand nichtfachlicher Beispielen. „Nichtfachlich“ bedeutet in diesem Fall, dass keine Konzepte aus einem konkreten Anwendungsgebiet von ISOM und ISOM/L wie zum Beispiel der Programmierung von Steuergeräten in Kraftfahrzeugen behandelt werden. Für eine fachliche Einführung in dieses Thema wird auf die jeweilige OEMspezifische Dokumentation verwiesen. Hinweis: Das nebenstehende Symbol markiert in diesem Dokument nützliche Hinweise und Empfehlungen. Achtung: Das nebenstehende Symbol markiert in diesem Dokument Warnungen und dringende Empfehlungen. 7 von 109 1 Einführung Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Das Handbuch gliedert sich wie folgt: 8 von 109 1 Einführung Kapitel 2 führt anhand kommentierter Beispiele in die Sprache ISOM/L ein. Kapitel 3 stellt die Kontrollstrukturen für Schleifen und bedingte Codeausführung vor. Kapitel 4 beschreibt detailliert die Grundlagen des ISOM/L-Objektmodells. Wie ISOM/L-Programme strukturiert werden, beschreibt Kapitel 5. Kapitel 6 erklärt die Ein- und Ausgabe von Daten mit ISOM/L. Kapitel 7 zeigt die Verwendung von Objekten zur Interaktion mit dem Benutzer und ihre Darstellung an der Bedienoberfläche. Kapitel 8 erläutert die Verwendung des ISOM/L-Interpreters und weiterer Werkzeuge. Kapitel 9 enthält die Syntaxgraphen der Sprache. Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 2 Eine Einführung in ISOM/L In diesem Kapitel werden zunächst ausgewählte Eigenschaften von ISOM/L anhand eines kurzen Beispiels näher erläutert. Die Erläuterungen sollen dem Programmierer ein Gefühl für die Verwendung von ISOM/L vermitteln und stellen keine formale Definition dar. Die formale Definition der Sprache ISOM/L in Form von Syntaxgraphen wird in Kapitel 9 vorgestellt. Zur Verwendung des ISOM-Interpreters siehe Kapitel 8.1. 2.1 Hello, world Codeauszug 1 zeigt ein minimal vollständiges ISOM/L-Programm, das, wie es die Tradition von jeder Einführung in eine Programmiersprache verlangt, die Zeichenkette „Hello, world!“ auf der Standardausgabe ausgibt. Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 /* * ISOM/L-Beispielprogramm: HelloWorld.is * erste Version */ namespace HelloWorld { Isom.Base.Boolean main () { Isom.Sys.System.Stdout("Hello, world!"); return true; } } Codeauszug 1: HelloWorld.is Dieses kurze Beispielprogramm wird nachfolgend erläutert und erweitert. 2.1.1 Ausführung Die Beispiele, die in diesem Handbuch gezeigt werden, sind in ISOM Didact [1] enthalten. Alternativ können sie in einem beliebigen Texteditor eingegeben werden. 9 von 109 2 Eine Einführung in ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Wurde die Testumgebung wie in Kapitel 8.1.1 beschrieben vorbereitet, kann das Programm „Hello, world“ wie folgt mit dem ISOM-Interpreter ausgeführt werden: Abbildung 1: Ausführung des Programms „Hello, world“ 2.1.2 Grundlegendes Die Syntax von ISOM/L basiert auf der Syntax der C-verwandten Sprachen. Schlüsselwörter und Bezeichner sind groß-/kleinschreibungsabhängig; daher stellen zum Beispiel test und Test 10 von 109 2 Eine Einführung in ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München unterschiedliche Bezeichner dar. Anweisungen sind mit einem Semikolon („;“) abzuschließen. Leere Anweisungen sind zulässig. Anweisungen können zu Blöcken gruppiert werden, die durch geschweifte Klammern („{“ und „}“) begrenzt werden. Zuweisungen verwenden das einfache Gleichheitszeichen (=). Zulässige Trennzeichen sind Leerzeichen, Tabulatorzeichen und Zeilenumbruch. Hinweis: Von der Verwendung des Tabulatorzeichens für Einrückungen wird abgeraten, um ein einheitliches Aussehen der Programme auf verschiedenen Systemen zu gewährleisten. 2.1.3 Kommentare Codeauszug 1 beginnt mit einem Kommentar. Kommentare erläutern den ISOM/L-Quellcode. Ihr Inhalt wird vom Interpreter nicht weiterverarbeitet. Kommentare entsprechen dem C-Stil. Mit „//“ werden Kommentare begonnen, die bis zum Ende der aktuellen Zeile reichen (Zeilenkommentare). Zusätzlich können sich Kommentare auch über mehrere Zeilen oder Teile von Zeilen erstrecken (Blockkommentare), wenn sie mit „/*“ begonnen und mit „*/“ abgeschlossen werden. Blockkommentare können Zeilenkommentare umschließen, nicht jedoch andere Blockkommentare. Das erste Auftreten der Zeichenfolge „*/“ beendet den Blockkommentar unabhängig davon, wie oft die Zeichenfolge „/*“ in diesem Blockkommentar vorkommt. 11 von 109 2 Eine Einführung in ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 // Dies ist ein Zeilenkommentar. /* Dies ist ein Blockkommentar, der sich über mehrere Zeilen erstreckt. */ /* Dies ist ein Blockkommentar in einer Zeile. */ /* * Dies ist ein Blockkommentar mit "*" * als Dekoration an jedem Zeilenanfang. Diese Dekoration * ist nicht Bestandteil der Kommentar-Syntax von ISOM/L. */ /* Dies ist ein Blockkommentar, der einen // Zeilenkommentar umschließt. Er ist erst hier zu Ende. */ /* Dies ist ein Blockkommentar, in dem sich der Beginn eines /* weiteren Blockkommentars befindet. Der gesamte Kommentar ist hier zu Ende. */ Diese Zeile ist kein gültiger Kommentar und führt zu einem Fehler. */ Codeauszug 2: Kommentare 2.1.4 Namensräume Bei der nächsten Anweisung (namespace …) aus Codeauszug 1 handelt es sich um die Definition eines Namensraums mit dem Namen HelloWorld. Ein Namensraum ist eine Sammlung von Funktionen. Die Funktionen eines Namensraums werden vom Programmierer in ISOM/L definiert. Im vorliegenden Beispiel enthält der Namensraum nur die im folgenden Kapitel 2.1.5 beschriebene main-Funktion. Ein Namensraum wird definiert durch das Schlüsselwort namespace, gefolgt vom Namensraumbezeichner und einer öffnenden geschweiften Klammer ({). Dem schließen sich eine beliebige Anzahl von Funktionsdefinitionen an, gefolgt von einer schließenden geschweiften Klammer (}). Namensraumbezeichner können hierarchisch aufgebaut sein und spielen eine wichtige Rolle bei der Strukturierung des 12 von 109 2 Eine Einführung in ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodes und der Datei- und Verzeichnisstruktur der ISOM/LProgramme auf Speichermedien. Namensräume werden in Kapitel 5 detailliert vorgestellt. An dieser Stelle sei nur festgehalten, dass eine Funktion stets innerhalb eines Namensraums definiert werden muss, d.h. die Angabe eines Namensraums ist auch für diese einfachen Beispielprogramme notwendig. 2.1.5 Die main-Funktion Im Kommandozeilenmodus wird die main-Funktion des übergebenen ISOM/L-Programms ausgeführt. Achtung: Gibt es im Kommandozeilenmodus keine main-Funktion in dem betreffenden Programm, wird die Ausführung nicht begonnen und eine Warnung ausgegeben. Für die Definition der main-Funktion gilt sonst dasselbe wie für jede andere ISOM/L-Funktion: Eine Funktionsdefinition besteht aus dem Typbezeichner, der den Rückgabetyp darstellt, gefolgt vom Namen der Funktion. Dem folgt eine Parameterdeklarationsliste (in runden Klammern „()“, durch Komma getrennt) sowie eine Anweisung oder mehrere zu einem Block zusammengefasste Anweisungen. Eine Parameterdeklaration besteht aus einem Typbezeichner, gefolgt von einem Parameternamen. Im Beispiel der main-Funktion aus dem Programm „Hello, world“ ist Isom.Base.Boolean der Typbezeichner des Rückgabetyps und main der Funktionsname. Die Parameterdeklarationsliste ist leer. Die Anweisung besteht aus einem mit geschweiften Klammern gruppierten Block, der wiederum zwei Anweisungen enthält. Die erste dieser Anweisungen wird im nachfolgenden Kapitel 2.1.6 erläutert. Die zweite Anweisung mit dem Schlüsselwort return verlässt die Funktion und liefert den Rückgabewert vom Typ Isom.Base.Boolean – in diesem Fall true - zurück. 2.1.6 Ausgabe von Zeichenketten über die Standardausgabe Die erste Anweisung innerhalb des Blocks der main-Funktion gibt die Zeichenkette Hello, world! in den Standardausgabestrom aus. Der Programmierer ruft dazu die Fachfunktion Stdout des ISOM-Objekts Isom.Sys.System auf. Ihr wird als Parameter die 13 von 109 2 Eine Einführung in ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München auszugebende Zeichenkette Hello, world! übergeben. In Zeichenketten sind alle Zeichen bis auf Textbegrenzungszeichen („"“) erlaubt. Die Fachfunktion Stdout fügt nach der Zeichenkette selbsttätig ein zusätzliches Zeilentrennzeichen in den Standardausgabestrom ein [2]. 2.1.7 Zusammenfassung Damit ist die einführende Beschreibung des einfachen Beispielprogramms „Hello, world“ abgeschlossen. Codeauszug 3 zeichnet die beschriebenen Sprachelemente nochmals mit erklärenden Kommentarzeilen aus. Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 /* * ISOM/L-Beispielprogramm: Hello, world * zweite Version, mit Kommentaren */ // // // // Kommentar Kommentar Kommentar Kommentar namespace HelloWorld // Namensraumdeklaration { // Beginn Namensraum Isom.Base.Boolean main() // Funktionsdefinition { // Beginn Anweisungsblock Isom.Sys.System.Stdout("Hello, world!"); // Standardausgabe return true; // Verlassen der Funktion } // Ende Anweisungsblock } // Ende Namensraum Codeauszug 3: HelloWorldWithComments.is 2.2 Hello, world – erweiterte Version Codeauszug 1 ist nur minimal vollständig und nutzt nicht alle Möglichkeiten der Sprache ISOM/L aus. Zwei dieser Möglichkeiten sollen nachfolgend noch vorgestellt werden: die Importanweisung und Textdefinitionen. 2.2.1 Import von Namensräumen mit using Alle Typen des ISOM-Objektmodells werden aus dem Namensraum HelloWorld heraus mit ihren vollqualifizierten Typnamen referenziert (Isom.Base.Boolean, Isom.Sys.System). Im vorliegenden Fall sind Isom.Base bzw. Isom.Sys die Bezeichner des Namensraums, in dem die jeweilige Klasse Boolean bzw. System definiert ist. 14 von 109 2 Eine Einführung in ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Die Angabe vollqualifizierter Typnamen erfordert Aufwand bei der Eingabe und führt bei umfangreicheren Programmen schnell zu schwer lesbaren Anweisungen. ISOM/L unterstützt deshalb den Import von Typen, die in anderen Namensräumen definiert sind, über die Importanweisung. Vor der Definition eines Namensraums können beliebig viele Importanweisungen stehen. Eine Importanweisung besteht aus dem Schlüsselwort using, gefolgt vom vollqualifizierten Typnamen des zu importierenden Typs und einem Semikolon („;“). Quellcodeauszug 01 /* 02 * ISOM/L-Beispielprogramm: HelloWorldWithUsing.is 03 * Hello, world: dritte Version mit Importanweisungen 04 */ 05 06 using Isom.Base.Boolean; // importiere Typ "Isom.Base.Boolean" 07 using Isom.Sys.System; // importiere Typ "Isom.Sys.System" 08 09 namespace HelloWorld 10 { 11 /* Für "Isom.Base.Boolean" und "Isom.Sys.System" kann nun 12 * innerhalb des Namensraums "HelloWorld" 13 * auf die vollqualifizierte Angabe des Typnamens verzichtet werden. 14 */ 15 Boolean main () 16 { 17 Number i = 1; // Fehler: Typ "Number" ist in "HelloWorld" 18 // unbekannt 19 20 System.Stdout("Hello, world!"); 21 return true; 22 } 23 } Codeauszug 4: HelloWorldWithUsing.is Anstelle des Typnamens kann auch ein „*“ als Platzhalter stehen. In diesem Fall werden alle Typen innerhalb des Namensraums importiert. Nicht importiert werden hingegen Typen in weiteren Namensräumen, die unterhalb des angegebenen angesiedelt sind. Mit anderen Worten: „*“ ist ein Platzhalter für Typnamen, nicht für Namensraumbezeichner. 15 von 109 2 Eine Einführung in ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 /* 02 * ISOM/L-Beispielprogramm: HelloWorldWithUsing2.is 03 * Hello, world: vierte Version mit Importanweisungen und Platzhaltern 04 */ 05 06 using Isom.Base.*; /* importiere alle Typen in "Isom.Base", 07 08 using Isom.Sys.*; z.B. auch "Isom.Base.Number" */ // importiere alle Typen in "Isom.Sys" 09 10 namespace HelloWorld 11 { 12 /* für Typen in "Isom.Base" und "Isom.Sys" kann nun 13 * innerhalb des Namensraums "HelloWorld" 14 * auf die vollqualifizierte Angabe des Typnamens verzichtet werden. 15 */ 16 Boolean main () 17 { 18 Number i = 1; // OK: Typ "Isom.Base.Number" ist bekannt. 19 20 System.Stdout("Hello, world!"); 21 return true; 22 } 23 } Codeauszug 5: HelloWorldWithUsing2.is Die Importanweisung wird detailliert in Kapitel 5.2 beschrieben. 2.2.2 Textbezeichner ISOM/L bietet die Möglichkeit, Textbezeichner zu definieren. Diese Textbezeichner können daraufhin in ISOM/L-Programmen anstelle von Zeichenkettenliteralen verwendet werden. Wird ein Textbezeichner definiert, liegt eine Textdefinition vor. Jedem Textbezeichner wird eine Kategorie zugewiesen. Die zulässigen Kategorien kann der Programmierer in der Datei TextCategoryData.xml festgelegen, die sich im anwenderspezifischen Verzeichnis \<OEM>\ISOM\isoml befindet (vgl. auch die vorbereitenden Tätigkeiten, die in Kapitel 8.1.1 beschrieben sind). Nachfolgend wird davon ausgegangen, dass mindestens die Textkategorie „MESSAGE“ in dieser Datei definiert wurde. Textdefinitionen sind Bestandteil eines Namensraums und werden am Anfang des Namensraums vor den Funktionsdefinitionen angegeben. Es können beliebig viele (auch keine) Textdefinitionen am Anfang eines Namensraums stehen. Eine Textdefinition besteht 16 von 109 2 Eine Einführung in ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München aus dem Schlüsselwort deftext gefolgt vom Bezeichner der Kategorie und dem Textbezeichner selbst. Dem schließt sich der eigentliche Text an. Dieser Text ist ein Zeichenkettenliteral, wie in Kapitel 4.2 beschrieben. Textdefinitionen sind keine Anweisungen und werden daher nicht mit „;“ abgeschlossen. Codeauszug 6 zeigt das mit Textdefinitionen erweiterte Programm „Hello, world“. Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 /* * ISOM/L-Beispielprogramm: HelloWorldWithDeftext.is * Hello, world: fünfte Version mit Importanweisungen und * Textdefinition */ using Isom.Base.*; using Isom.Sys.*; namespace HelloWorld { 12 13 14 15 16 17 18 19 20 } // Definition des Textbezeichners HELLO_WORLD der Kategorie MESSAGE deftext MESSAGE HELLO_WORLD "Hello, world!" Boolean main () { System.Stdout(HELLO_WORLD); // Verwendung des Textbezeichners return true; } Codeauszug 6: HelloWorldWithDeftext.is Textdefinitionen dienen neben der Verwendung als Konstanten dazu, eine Serviceanwendung, die auf ISOM/L-Abläufen basiert, übersetzbar zu machen, d.h. die verwendeten Texte in verschiedenen Sprachen, in die sie vorher übersetzt wurden, anzeigen zu können. Mehr zu Textdefinitionen enthält Kapitel 5.3. 17 von 109 2 Eine Einführung in ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 3 Kontrollstrukturen ISOM/L verfügt über die aus anderen imperativen Programmiersprachen bekannten Kontrollstrukturen, mit einigen Besonderheiten. Die Beispiele in diesem Kapitel verwenden die in Kapitel 4 näher erläuterten Datentypen von ISOM/L für Zahlen und Zeichenketten. 3.1 Bedingte Codeausführung mit if/else Bedingte Codeausführung erfolgt nach dem Schema von C. Dem Schlüsselwort if folgt als Bedingung ein boolescher Ausdruck in runden Klammern, dem wiederum eine Anweisung folgt. Diese wird ausgeführt, wenn die Bedingung als „wahr“ ausgewertet wird. Optional können ein else und eine weitere Anweisung folgen. Diese Anweisung wird ausgeführt, wenn die Bedingung zu „falsch“ ausgewertet wird. Beide Anweisungen können Blöcke oder einzelne Anweisungen sein. Codeauszug 7 und Codeauszug 8 zeigen die Verwendung von if/else zusammen mit weiteren Sprachelementen (Zahlen, Wörterbücher, Void-Objekte), die in den nachfolgenden Kapiteln detailliert vorgestellt werden. 18 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 3 Kontrollstrukturen using Isom.Sys.*; using Isom.Base.*; namespace IfElseStdio { deftext MESSAGE MSG_ERR "Fehler bei der Eingabe. "\ "Bitte starten Sie das Programm neu und geben Sie "\ "zwei ganze Zahlen ein." Number ReadNumber() { // Meldung auf Standardausgabe schreiben System.Stdout("Bitte geben Sie eine ganze Zahl ein: "); 22 23 24 // Zeichenkette von Standardeingabe lesen String str = System.Stdin(); 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 // als Zahl interpretieren Number num = str.ParseNumber(); 42 43 44 45 46 47 48 19 von 109 /* * ISOM/L-Beispielprogramm: IfElseStdio.is * Einlesen und Verarbeiten von Zahlen, * bedingte Codeausführung mit "if/else" */ return num; } Boolean main () { Number a = ReadNumber(); Number b = ReadNumber(); if(a.IsVoid().Or(b.IsVoid())) { System.Stderr(MSG_ERR); return false; } // Multiplizieren Number prod = a.Clone(); // Wert von a sichern prod.Mul(b); // Wert von prod wird verändert Boolean even = prod.Mod(2).Eq(0); String msg = "Das Produkt von $(a) und $(b) ist $(evenness)"; msg.Replace("$(a)", a.ToIntString()); // Unveränderte Werte von Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 } msg.Replace("$(b)", b.ToIntString()); // a und b ausgeben // Bedingte Codeausführung mit "if/else" if (even) // Produkt beider Zahlen ist gerade { msg.Replace("$(evenness)", "gerade"); } else // Produkt beider Zahlen ist ungerade { msg.Replace("$(evenness)", "ungerade"); } /*********************************************************/ /* In diesem Fall alternativ auch ohne Gruppierung möglich, * da die Blöcke jeweils nur eine Anweisung enthalten: if (even) msg.Replace("$(evenness)", "gerade"); else msg.Replace("$(evenness)", "ungerade"); */ /*********************************************************/ System.Stdout(msg); return true; } Codeauszug 7: IfElseStdio.is 20 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 21 von 109 3 Kontrollstrukturen /* * ISOM/L-Beispielprogramm: IfElseEnv.is * Bedingte Codeausführung mit if/else */ using Isom.Base.*; using Isom.Sys.*; using Isom.Context.*; namespace IfElseEnv { deftext MESSAGE MSG_ERR "Bitte per Kommandozeilenparameter '-Env' "\ "zwei Variablen namens 'valA' und 'valB' definieren und auf "\ "numerische Werte setzen. "\ "Beispiel: IsomInstance.exe -Env=valA:5,valB=7" Boolean main () { StringDictionary dict = Environment.GetInstance().GetAllEnvironmentVars(); String valA = dict.Get("valA"); String valB = dict.Get("valB"); if(valA.IsVoid().Or(valB.IsVoid())) { System.Stderr(MSG_ERR); return false; } Number a = valA.ParseNumber(); Number b = valB.ParseNumber(); if(a.IsVoid().Or(b.IsVoid())) { System.Stderr(MSG_ERR); return false; } // Multiplizieren a.Mul(b); // Wert von a wird verändert Boolean even = a.Mod(2).Eq(0); String msg = "Das Produkt von $(a) und $(b) ist $(evenness)"; msg.Replace("$(a)", valA); // Zeichenketten valA und valB msg.Replace("$(b)", valB); // sind unverändert // Bedingte Codeausführung mit "if/else" if (even) // Produkt beider Zahlen ist gerade Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 49 50 51 52 53 54 55 56 { 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 } /*********************************************************/ /* In diesem Fall alternativ auch ohne Gruppierung möglich, * da die Blöcke jeweils nur eine Anweisung enthalten: msg.Replace("$(evenness)", "gerade"); } else // Produkt beider Zahlen ist ungerade { msg.Replace("$(evenness)", "ungerade"); } if (even) msg.Replace("$(evenness)", "gerade"); else msg.Replace("$(evenness)", "ungerade"); */ /*********************************************************/ System.Stdout(msg); return true; } Codeauszug 8: IfElseEnv.is 3.2 Bedingte Codeausführung mit switch/case/default Bedingte Codeausführung kann zudem über das switch-Konstrukt erfolgen. Dem Schlüsselwort switch folgt in runden Klammern eine Variable, deren Zustand geprüft werden soll. Diese Variable kann eine Zeichenkette (Typ String), eine Zahl (Typ Number) oder eine Bedingung (Typ Boolean) sein. Dem folgt ein in geschweiften Klammern („{“, „}“) eingeschlossener Block. Innerhalb dieses Blocks steht eine Liste möglicher Werte, die die Variable annehmen kann, mit dem in diesem Fall auszuführenden Code. Eine solche Fall-Anweisung beginnt mit dem Schlüsselwort case, gefolgt von dem Wert, auf den die Variable geprüft werden soll. Dieser Wert muss ein Literal (siehe 4.2) sein. Dem folgt ein Doppelpunkt. Anschließend folgt die Anweisung, die ausgeführt werden soll, wenn die Variable den geprüften Wert hat. Diese Anweisung kann eine einzelne Anweisung oder ein Block sein. 22 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Die Liste der möglichen Fälle wird der Reihe nach durchgegangen, bis eine Übereinstimmung gefunden wird. Wichtiger Hinweis: Am Ende des switch-Konstrukts muss die Anweisung default: stehen. Dieser Standardfall ist zwingend vorgeschrieben. Die auf ein default folgende Anweisung wird ausgeführt, wenn vorher keine Übereinstimmung gefunden wurde. Ein „Durchfallen“ von einem case-Block zum nächsten wie in C sowie ein break innerhalb des switch-Konstrukts sind in ISOM/L syntaktisch nicht zulässig. Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 // Bedingte Codeausführung mit "switch/case/default" String s; String t; ... switch (s) { case "Fall 1": t = "Das ist Fall 1"; case "Fall 2": t = "Das ist Fall 2"; default: t = "Standardfall"; } Codeauszug 9: Bedingte Codeausführung mit switch/case/default 3.3 Schleifen In ISOM/L gibt es nur eine Art von Schleifen. Diese entspricht der while-Schleife von C. Dem Schlüsselwort while folgt in runden Klammern eine Bedingung. Der Bedingung schließt sich eine Anweisung (entweder ein Block oder eine einzelne Anweisung) an. Diese wird wiederholt, solange die Bedingung wahr ist. Die Anweisung break innerhalb einer while-Schleife bewirkt das sofortige Beenden der gesamten Schleife. Die Anweisung continue bewirkt das sofortige Verlassen des aktuellen Schleifendurchlaufs. Die Abarbeitung springt daraufhin direkt zur erneuten Auswertung der Bedingung. 23 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 /* * ISOM/L-Beispielprogramm: Berechnung der Fakultät von 10. * Factorial.is */ using Isom.Base.*; using Isom.Sys.*; namespace Factorial { Number Fac (Number x) { if(x.Lt(0)) { return Number.Void(); } if(x.Eq(0)) { return 1; } Number fac = x; while(x.Gt(1)) // while-Schleife { x.Sub(1); fac.Mul(x); } return fac; } Boolean main () { Number a = Fac (10); String msg = "Die Fakultät von 10 ist $1."; msg.Replace ("$1", a.ToIntString ()); System.Stdout (msg); return true; } } Codeauszug 10: Factorial.is 24 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 3.4 Abschließende Blöcke Der Kontrollfluss in ISOM/L-Funktionen kann an vielen Stellen mit einer Funktionsrückgabe enden. Codeabschnitte, die immer vor dem Verlassen einer Funktion ausgeführt werden sollen, können in einen abschließenden Block ausgelagert werden. Ein abschließender Block vermeidet auf diese Weise die mehrfache Implementierung dieser Codeabschnitte. Abschließende Blöcke werden mit dem Schlüsselwort finally eingeleitet. 25 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 /* * ISOM/L-Beispielprogramm: Abschließender Block. * FinallyBlock.is */ using Isom.Base.*; using Isom.Sys.*; namespace FinallyBlock { Boolean main () { { if( … ) // Auswertung einer Bedingung return true; // Verlässt die Funktion mit 'wahr' if( … ) return false; // Verlässt die Funktion mit 'falsch' … return true; // Verlässt die Funktion mit 'wahr' } finally // Leitet einen abschließenden Block ein { //Wird zwischen return und Verlassen der Funktion ausgeführt: System.Stdout("main-Funktion beendet."); } } } Codeauszug 11: FinallyBlock.is Das Programm in Codeauszug 11 gibt am Ende der Funktion main auf der Konsole eine Nachricht aus. Die Ausgabe erfolgt in allen drei Ausführungspfaden, auf denen das Programm verlassen werden kann, gleichermaßen. Ein abschließender Block darf jedem Block folgen, der selbst kein abschließender Block ist, der kein Funktionsrumpf ist und der nicht einem Fall einer switch-Anweisung zugeordnet ist. Nach Fallunterscheidungen mit if oder switch und nach Schleifen mit while ist ebenfalls ein abschließender Block erlaubt. Der Befehl leave verlässt vorzeitig einen Block und führt den zugehörigen abschließenden Block aus. Achtung: Ohne einen abschließenden Block, den ein finally einleitet, darf leave nicht verwendet werden. Abschließende Blöcke werden auch ausgeführt, wenn der vorangegangene Block nicht vorzeitig durch einen der Sprungbefehle 26 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München return, leave, break oder continue verlassen wird. Innerhalb abschließender Blöcke sind Sprungbefehle nicht erlaubt. Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 /* * ISOM/L-Beispielprogramm: Abschließender Block und leave-Anweisung. * FinallyBlockAndLeave.is */ using Isom.Base.*; using Isom.Sys.*; namespace FinallyBlockAndLeave { Boolean main () { { if( … ) // Auswertung einer Bedingung leave; // Sprung in den abschließenden Block … } finally // Leitet einen abschließenden Block ein { System.Stdout("main-Funktion beendet."); } return true; } } Codeauszug 12: FinallyBlockAndLeave.is Die Ausführung der leave-Anweisung in Codeauszug 12 führt zur Fortsetzung der Programmausführung im abschließenden Block. 27 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 /* * ISOM/L-Beispielprogramm: Abschließender Block nach if-Anweisung. * FinallyBlockAfterIfElse.is */ using Isom.Base.*; using Isom.Sys.*; namespace FinallyBlockAfterIfElse { Boolean main () { if( … ) // Auswertung einer Bedingung { … // Behandlung, wenn Bedingung wahr ist } else { … // Behandlung, wenn Bedingung falsch ist } finally // Leitet einen abschließenden Block ein { System.Stdout("Fallunterscheidung beendet."); } return true; } } Codeauszug 13: FinallyBlockAfterIfElse.is Der abschließende Block in Codeauszug 13 wird nach beiden unterschiedenen Fälle der if-Fallunterscheidung ausgeführt. 28 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 /* * ISOM/L-Beispielprogramm: Abschließender Block nach switch-Anweisung. * FinallyBlockAfterSwitch.is */ using Isom.Base.*; using Isom.Sys.*; namespace FinallyBlockAfterSwitch { Boolean main () { String s = …; switch( s ) { case "Fall 1": // Variable s ist gleich "Fall 1" … case "Fall 2": // Variable s ist gleich "Fall 2" … default: // In allen anderen Fällen … } finally // Leitet einen abschließenden Block ein { System.Stdout("Fallunterscheidung beendet."); } return true; } } Codeauszug 14: FinallyBlockAfterSwitch.is Der abschließende Block in Codeauszug 14 wird nach jedem der unterschiedenen Fälle der switch-Fallunterscheidung ausgeführt. 29 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 /* * ISOM/L-Beispielprogramm: Abschließender Block nach while-Schleife. * FinallyBlockAfterWhile.is */ using Isom.Base.*; using Isom.Sys.*; namespace FinallyBlockAfterWhile { Boolean main () { while( … ) // Auswertung der Schleifenbedingung { … // Schleifenrumpf } finally // Leitet einen abschließenden Block ein { System.Stdout("while-Schleife beendet."); } } } Codeauszug 15: FinallyBlockAfterWhile.is Der abschließende Block in Codeauszug 15 wird nach Beenden der Schleife einmalig ausgeführt. Wie oft der Schleifenrumpf durchlaufen wurde, ist unerheblich. Auch wenn der Schleifenrumpf keinmal durchlaufen wurde, wird der abschließende Block ausgeführt. 30 von 109 3 Kontrollstrukturen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 4 Grundlagen des ISOM/L-Objektmodells In den Beispielen zu den Kontrollstrukturen von ISOM/L im vorangegangenen Kapitel wurden bereits Variablen verschiedener Datentypen definiert und Operationen auf ihnen ausgeführt. Das vorliegende Kapitel beleuchtet detailliert die Grundlagen des ISOM-Objektmodells und seiner Datentypen. 4.1 Objekte als grundlegendes Paradigma Ein Objekt ist ein Container, der Daten und Methoden enthält. Eine Methode ist eine Funktion, die einem Objekt zugeordnet ist und über die ggf. die in dem Objekt enthaltenen Daten manipuliert werden können. Eine Klasse ist die abstrakte Definition eines Objekts, auf deren Grundlage konkrete Instanzen des Objekts erzeugt werden können. Die Methoden, die die ISOM/L-Bibliothek für Serviceautoren [2] bereitstellt, werden Fachfunktionen genannt. Bei den Fachfunktionen ist zu unterscheiden zwischen instanzlosen und instanzgebundenen Fachfunktionen. Eine instanzlose Fachfunktion gehört zu einer bestimmten Klasse, aber nicht zu einer konkreten Objektinstanz dieser Klasse. Sie kann jederzeit aufgerufen werden, ohne dass vorher eine Objektinstanz erzeugt werden muss. Instanzlose Fachfunktionen greifen daher auch nicht auf die Daten einer konkreten Objektinstanz zu. Eine instanzgebundene Fachfunktion hingegen wird immer auf einer konkreten Objektinstanz aufgerufen. Nur instanzgebundene Fachfunktionen können daher direkt die Daten eines konkreten Objekts manipulieren. 4.1.1 Variablendefinition in ISOM/L In ISOM/L gibt es keine primitiven Datentypen. Stattdessen werden alle Daten als Objekte abgebildet. Codeauszug 16 veranschaulicht die Definition von Variablen und die Zuweisung von Objektinstanzen zu Variablen. 31 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 // Definition ohne Zuweisung <Typ> <Variablenname>; // Definition mit gleichzeitiger Zuweisung <Typ> <Variablenname> = <Ausdruck>; 07 // Zuweisung an eine bereits definierte Variable 08 <Variablenname> = <Ausdruck>; Codeauszug 16: Variablendefinition und Zuweisung <Typ> bezeichnet hier grundsätzlich den Namen einer Klasse. <Ausdruck> ist ein gültiger Ausdruck in ISOM/L. Da es keine primitiven Datentypen gibt, wird jeder Ausdruck zu einer Objektinstanz ausgewertet. Diese wird daraufhin im Fall von Codeauszug 16 dem Bezeichner <Variablenname> zugewiesen. Gültige Ausdrücke sind Literale (siehe Kapitel 4.2), Variablen und Funktionsaufrufe. In ISOM/L gibt es keine arithmetischen oder logischen Ausdrücke. Um die Sprache einfach zu gestalten, werden alle gängigen Operatoren als Fachfunktionen der entsprechenden Objekte abgebildet. Das ist sinnvoll, da es keine primitiven Datentypen in ISOM/L gibt, sondern nur Objekte. 4.2 Basisobjekte Eine besondere Rolle spielen die sogenannten Basisobjekte Boolean, Number und String. Diese ersetzen die entsprechenden primitiven Datentypen anderer Sprachen. Basisobjekte zeichnen sich dadurch aus, dass sie durch Zuweisung eines Literals erzeugt werden können. Gültige Literale für Boolean-Objekte sind die Schlüsselwörter true und false, die die Zustände „wahr“ bzw. „falsch“ repräsentieren. Gültige Literale für Zeichenketten (Typ String) sind beliebige Texte, die in gerade Anführungszeichen eingeschlossen sind (<text>). In Zeichenketten sind alle Zeichen außer Textbegrenzungszeichen („"“) erlaubt. Längere Zeichenketten können auf mehrere Zeilen verteilt und mit dem umgekehrten Schrägstrich (\) verkettet werden. Dieses Zeichen stellt keinen Laufzeitoperator dar, da die Verkettung der Texte bereits beim Einlesen der Programme erfolgt. Numerische Literale sind entweder Dezimal- oder Hexadezimalzahlen. Dezimalzahlen bestehen aus den Ziffern 0 bis 9. Das Dezimaltrennzeichen ist der Punkt („.“). Einer Ziffernfolge kann ein Minuszeichen („-“) vorangestellt sein. Dezimalzahlen 32 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München können einen Exponenten enthalten. Dieser wird an die Grundzahl angehängt. Ein Exponent besteht aus einem „e“ (oder „E“), gefolgt von einer Ganzzahl. Hexadezimalzahlen beginnen mit „0x“, daran schließt sich eine Folge von Hexadezimalziffern an. Hexadezimalziffern sind 0 bis 9 sowie die Buchstaben a bis f. Die Buchstaben können großoder kleingeschrieben werden. In Codeauszug 17 sind einige Beispiele für Literale aufgeführt. Quellcodeauszug 01 02 03 04 05 06 07 Boolean fail = false; String message = "Bitte Anweisungen beachten"; String veryLongString = "Dies ist ein sehr, sehr, sehr " \ "langes Zeichenkettenliteral."; Number pi = 3.1415; Number hexZahl = 0x18af2b; Number zahlMitExponent = -1.79769313486232E-308; Codeauszug 17: Beispiele für Literale 4.3 Sonderbehandlung der Klassen Boolean und Number Generell sind Objekte in ISOM/L Referenztypen. Wenn eine Variable einer anderen zugewiesen wird, stellen nach der Zuweisung beide Variablen folglich dasselbe Objekt dar. Diese Vorgehensweise hat das sogenannte Aliasing zur Folge: Wird nach einer Operation auf der einen Variable das Objekt verändert, stellen anschließend beide Variablen das veränderte Objekt dar. Dies entspricht nicht dem, was für primitive Datentypen in der Regel zu erwarten wäre. In den meisten Programmiersprachen sind primitive Datentypen Werttypen. Bei der Zuweisung von Werttypen entsteht kein Aliasing, da keine Referenz, sondern der Wert der ursprünglichen Variablen zugewiesen wird. Das heißt, wenn sich nach der Zuweisung der Wert einer Variablen verändert, hat das keine Auswirkung auf die andere Variable. Um der für primitive Datentypen allgemein üblichen Vorgehensweise (d.h. kein Aliasing) Rechnung zu tragen, werden in ISOM/L die Typen Boolean und Number in Abweichung von allen anderen Objekten als Werttypen implementiert. Das bedeutet, dass bei einer Zuweisung eines Objekts dieser Typen an eine neue Variable zuerst eine Kopie des Objekts erzeugt wird und danach die Kopie zugewiesen wird. 33 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 4.4 Fachfunktionen statt Operatoren In ISOM/L gibt es keine mathematischen oder logischen Operatoren. Diese Funktionalität übernehmen Fachfunktionen der Basisobjekte. Codeauszug 18 zeigt die Verwendung dieser FachfunkFachfunktionen. Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 // Fachfunktionen von Boolean Boolean b1 = true; // Werte von: b1 // true b2 Boolean b2 = b1.Not (); // true false Boolean b3 = b1.And (b2); // true false false Boolean b4 = b2.Or (b3); // true false false // Fachfunktionen von Number Number n = 1; // Werte von: n // 1 m Number m = n.Add (5); // 6 Number x = m.Sub (1); // Number y = x.Mul (n); // Number z = y.Div (m.Add (5)); // Number n = 1; // Number m = n.Clone ().Add (5); // Number x = m.Clone ().Sub (1); // Number y = x.Clone ().Mul (m); // 6 5 b3 x y b4 false z 5 30 30 10 3 3 1 6 5 30 Number z = y.Clone ().Div (m.Clone ().Add (4)); // 3 // Fachfunktionen von String String msg = "Hello "; String msg2 = msg.Append ("World"); msg2.Append ("!!!"); Boolean test = msg.Equals ("Hello World!!!"); // test == true Boolean test2 = msg2.Equals ("Hello World!!!"); // test2 == true String msg = "Hello "; String msg2 = msg.Clone ().Append ("World"); msg.Append ("1"); msg2.Append (" 2"); Boolean test = msg.Equals ("Hello 1"); // test == true Boolean test2 = msg2.Equals ("Hello World 2"); // test2 == true Codeauszug 18: Beispiele für Fachfunktionen der Basisobjekte Die Fachfunktionen der Klasse Boolean verändern das jeweilige Objekt nicht. Im Gegensatz dazu haben die Fachfunktionen von Number und String die Änderung des Objekts selbst zur Folge. Wenn zum Beispiel eine Zeichenkette mit Append () an eine Zeichenkette angehängt wird, verändert sich diese Zeichenkette. Dasselbe gilt für die Fachfunktionen auf den Zahlenobjekten. 34 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Der Rückgabewert der Fachfunktion eines Basisobjekts ist immer das veränderte Objekt selbst, genauer gesagt, dieselbe Objektinstanz. Im Fall der Zahlenobjekte wird bei der Zuweisung des Rückgabewerts an eine andere Zahlenvariable automatisch eine Kopie erzeugt, da Zahlen als Werttypen implementiert sind (siehe Kapitel 4.3). Bei Zeichenketten referenzieren nach einer Zuweisung beide Variablen dieselbe Objektinstanz. Im obigen Beispiel verweisen die Variablen msg und msg2 in der ersten Gruppe zeichenkettenrelevanter Anweisungen nach der Zuweisung auf dasselbe Objekt. Die anschließende Änderung von msg2 verändert daher auch msg. In der jeweils zweiten Gruppe von Anweisungen im obigen Beispiel wird jeweils vor dem Aufruf einer Fachfunktion auf einem Zahlen- bzw. Zeichenkettenobjekt eine Kopie des Objekts erzeugt. Dies geschieht mit der Fachfunktion Clone (). Anschließend wird auf der Kopie weitergearbeitet. Dadurch verändert sich das ursprüngliche Objekt nicht. Der Rückgabewert einer auf der Kopie aufgerufenen Fachfunktion ist die Kopie, die durch die Fachfunktion verändert wurde, d.h. eine andere Objektinstanz als das ursprüngliche Objekt. Die unterschiedlichen Auswirkungen der Aufrufe mit und ohne Clone () sind in den Kommentaren neben den entsprechenden Anweisungen in Codeauszug 18 dargestellt. 4.5 Objektbasiert statt objektorientiert ISOM/L ist eine objektbasierte, aber keine objektorientierte Sprache. ISOM/L unterstützt, wie bereits beschrieben, die Kapselung von Variablen, Zuständen und Fachfunktionen innerhalb der nativ zur Verfügung gestellten Objekte. ISOM/L unterstützt dagegen keine Vererbung oder Polymorphie. Ein Programmierer kann in seinen Programmen die von ISOM bereitgestellten Klassen und die Objektinstanzen, die aus diesen Klassen erzeugt werden, verwenden. Er kann aber selbst keine neuen Klassen definieren, aus denen neue Objektinstanzen erzeugt werden könnten. Das Objektmodell von ISOM ist daher aus Sicht des ISOM/L- Programmierers abgeschlossen. Alle von ISOM zur Verfügung gestellten Klassen sind in [2] zusammengefasst. 35 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 4.5.1 Klassen, Namensräume und Funktionen Der Programmierer kann statt neuer Klassen neue Namensräume definieren. Ein Namensraum ist eine Sammlung von Funktionen, die fachlich zusammengehören. Er ist vergleichbar mit einer Klasse, die nur instanzlose Fachfunktionen enthält – mit dem Unterschied, dass die Fachfunktionen einer Klasse nativ in ISOM definiert sind und nicht vom Programmierer beeinflusst werden können. Im Gegensatz dazu werden die Funktionen eines Namensraums vom Programmierer in ISOM/L definiert. Die ISOM-Laufzeitumgebung verwaltet Klassen intern ebenfalls als Namensräume. Dies bedeutet für ISOM/L, dass Bezeichner von Klassen wie Namensraumbezeichner behandelt werden. Außerdem werden instanzlose Fachfunktionen von Klassen auf die gleiche Weise aufgerufen wie Funktionen, die in Namensräumen definiert sind. 4.5.2 Funktionsdefinitionen Eine Funktionsdefinition besteht aus dem Typbezeichner, der den Rückgabetyp darstellt, gefolgt vom Namen der Funktion. Dem folgt eine Parameterdeklarationsliste (in runden Klammern „()“, durch Komma getrennt) sowie eine Anweisung, die entweder einzeln oder als Block zusammengefasst sein kann. Eine Parameterdeklaration besteht aus einem Typbezeichner, gefolgt von einem Parameternamen. Zusammengefasst bezeichnet man dies als Signatur der Funktion. Die Typbezeichner für den Rückgabetyp und die Parametertypen müssen von ISOM bereitgestellten Klassen entsprechen. Ein Namensraum, der von einem Programmierer definiert wurde, ist als Rückgabe- oder Parametertyp nicht zulässig. Dies ist sinnvoll, da einzig von Klassen Objektinstanzen abgeleitet werden können, die wiederum Variablen zugewiesen werden können. Ein vom Programmierer definierter Namensraum als Rückgabetyp oder als Parameter wäre daher unsinnig. Auf den als Parameter übergebenen Objekten können innerhalb einer Funktion Fachfunktionen aufgerufen werden, die das Objekt verändern können. Das Objekt bleibt in diesem Fall auch nach der Rückkehr der Funktion verändert. Zuweisungen an die Parameter-Variablen sind hingegen innerhalb einer Funktion nicht zulässig. Codeauszug 19 verdeutlicht das Verhalten. 36 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 /* * ISOM/L-Beispielprogramm: ParameterPassing.is * Parameterübergabe in ISOM/L */ using Isom.Base.*; using Isom.Sys.*; namespace ParameterPassing { Boolean Modify(String str) { str.Append(", modifiziert"); String msg = "Inhalt der Zeichenkette innerhalb von 'Modify()': "; msg.Append(str); System.Stdout(msg); return true; } Boolean main () { String text = "Text"; String preMsg = "Inhalt der Zeichenkette vor 'Modify()': "; preMsg.Append(text); System.Stdout(preMsg); Modify(text); String postMsg = "Inhalt der Zeichenkette nach 'Modify()': "; postMsg.Append(text); System.Stdout(postMsg); return true; } } Codeauszug 19: ParameterPassing.is 37 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 /* * unzulässige Zuweisung an Parametervariablen */ using Isom.Base.*; using Isom.Sys.*; namespace ParameterPassingError { /* NICHT ZULÄSSIG: Zuweisung an Parametervariablen * Diese Funktion verursacht eine Fehlermeldung des ISOM-Interpreters. */ Boolean Assign(String str) { str = "zugewiesener Text"; String msg = "Inhalt der Zeichenkette innerhalb von 'Assign()': "; msg.Append(str); System.Stdout(msg); return true; } Boolean main () { String text = "Text"; String preMsg = "Inhalt der Zeichenkette vor 'Modify()': "; preMsg.Append(text); System.Stdout(preMsg); Assign(text); String postMsg = "Inhalt der Zeichenkette nach 'Modify()': "; postMsg.Append(text); System.Stdout(postMsg); return true; } } Codeauszug 20: Unzulässige Zuweisung an Parametervariablen Mit dem Schlüsselwort return wird die Funktion verlassen und der Rückgabewert zurückgeliefert. Codeauszug 21 veranschaulicht an einem Beispiel, wie ein Namensraum mit Funktionen definiert wird. 38 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 namespace Test 02 { 03 Number double (Number n) 04 { 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 } // Erzeuge Kopie durch // Zuweisung (da Typ Number) Number ntemp = n; return ntemp.Mul (2); } Number treble (Number n) { // Erzeuge Kopie direkt return n.Clone ().Mul (3); } Boolean addFive (Number n) { // Verändere Objekt selbst n.Add (5) return true; } Codeauszug 21: Beispiel für einen Namensraum mit Funktionen 4.6 Fachfunktionen von Objekten ISOM-Objekte enthalten Daten und Fachfunktionen. Die in den Objekten enthaltenen Daten sind gekapselt. Der Programmierer hat über ISOM/L-Programme keinen direkten Zugriff auf die in den Objekten enthaltenen Daten. Die Bereitstellung der Klassen und Objekte und deren interne Implementierung sind Aufgabe der ISOM-Laufzeitumgebung und für den ISOM/L-Programmierer transparent. Die Fachfunktionen, die in ISOM-Objekten enthalten sind, können vom Programmierer hingegen in ISOM/L-Programmen verwendet werden. Diese Fachfunktionen sind überwiegend instanzgebunden, d.h. sie beziehen sich auf eine konkrete Instanz des Objekts. Es gibt allerdings auch instanzlose Fachfunktionen in Klassen. 39 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 4.7 Grundlegendes zum ISOM-Objektmodell In ISOM/L gibt es keine direkt in die Sprache integrierte Möglichkeit, neue Objektinstanzen zu erzeugen. Es gibt weder ein Schlüsselwort new noch Konstruktoren, wie sie aus den gängigen objektorientierten Sprachen bekannt sind. Neue Objektinstanzen werden in ISOM grundsätzlich intern erzeugt, d.h. nicht als Bestandteil der Sprache ISOM/L. Die von ISOM bereitgestellten Klassen bieten instanzlose Fachfunktionen, die dem ISOM/LProgrammierer bei Bedarf die intern erzeugten Objektinstanzen zurückliefern. Fachfunktionen mit dem Namen GetInstance beziehen sich auf Objekte, von denen es im ISOM-Objektmodell nur eine Instanz gibt (sogenannte Singletons), zum Beispiel der Ist-Fahrzeugkontext. Die Fachfunktion GetInstance () liefert die (einzige) Instanz des betreffenden Objekts zurück. Klassen, von denen es mehrere Objektinstanzen geben kann, haben typischerweise eine Fabrikmethode, deren Name mit Create beginnt. Diese Methode erzeugt ein neues Objekt dieser Klasse und liefert es zurück. Ein Beispiel für eine Create-Methode ist die Fachfunktion zum Erzeugen eines neuen Wörterbuchs, die von der Wörterbuch-Klasse bereitgestellt wird. Codeauszug 22 zeigt die Beispiele. Quellcodeauszug 01 using Isom.Context.*; 02 using Isom.Base.*; 03 04 05 06 07 08 09 10 11 // ... // Fachobjekt für Umgebungseinstellungen wird zurückgeliefert // (siehe auch "IfElseEnv.is") Environment env = Environment.GetInstance(); // Neues Wörterbuch von Zeichenketten wird erzeugt StringDictionary strDict = StringDictionary.CreateStringDictionary(); Codeauszug 22: Fachfunktionen Objekterzeugung/-bereitstellung Nicht mehr referenzierte Objektinstanzen werden automatisch aus dem Speicher entfernt. Eine explizite Speicherfreigabe durch den ISOM/L-Programmierer ist nicht notwendig. 40 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 4.8 Das Void-Objekt Für die Fehlerbehandlung steht in ISOM/L das sogenannte VoidObjekt zur Verfügung, d.h. ein „leeres Objekt“. Ein Objekt, ungeachtet welchen Typs, wird beim Auftreten einer unerwarteten Ausnahme innerhalb einer seiner Fachfunktionen zu einem VoidObjekt. Wird eine Fachfunktion eines Void-Objekts aufgerufen, wird die Fachfunktion nicht abgearbeitet, sondern wiederum ein Void-Objekt zurückgeliefert. Durch dieses Vorgehen erreicht ISOM eine hohe Robustheit zur Laufzeit. Unerwartete Ausnahmen führen nicht zum Abbruch des Programms, sondern lediglich zur Weiterreichung von VoidObjekten. Es obliegt dem Programmierer, zu prüfen, ob ein Void-Objekt erzeugt wurde, und ggf. angemessene Fehlerbehandlungsmaßnahmen zu treffen, wo er dies für nötig erachtet. Zur Prüfung, ob ein Void-Objekt vorliegt, kann die Fachfunktion IsVoid() verwendet werden, die in allen ISOM/L-Klassen enthalten ist, aus denen Objektinstanzen erzeugt werden können. Diese Fachfunktion liefert immer einen booleschen Wert zurück: true, wenn das Objekt ein Void-Objekt ist, anderenfalls false. Dem Programmierer steht außerdem eine Void()-Fachfunktion zur Verfügung. Damit ist es möglich, ein Void-Objekt zu erzeugen. Dieses kann zum Beispiel für Rückgabewerte von Funktionen verwendet werden. 4.8.1 Ungültig-Machen von Objektinstanzen: Fachfunktion Void () In manchen Fällen kann es für den Programmierer sinnvoll sein, einer Variablen selbsttätig das Void-Objekt zuzuweisen, insbesondere, wenn die Variable als Rückgabewert einer Funktion verwendet wird. Alle Typen der ISOM/L-Bibliothek für Serviceautoren (IBS) [2], die über eine Fachfunktion IsVoid verfügen, enthalten ebenfalls eine instanzlose Fachfunktion Void (). Sie liefert das Void-Objekt zurück, das wiederum einer Variablen des Typs zugewiesen werden kann. 41 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 String GetAddressForAction(String actionName) 02 { 03 String retVal = String.Void(); // mit "Void"-Objekt initialisieren 04 switch (actionName) 05 { 06 case "Output": // wenn übergebener Name "Output" ist, 07 retVal = "42"; // Rückgabewert auf "42" setzen 08 default: // ansonsten nichts tun, 09 ; // d.h. retVal bleibt "Void" 10 } 11 return retVal; // retVal zurückgeben 12 } Codeauszug 23: Ungültig-Machen von Objektinstanzen mit Void() Die Semantikprüfung des ISOM-Interpreters verbietet die Zuweisung der Rückgabe eines Aufrufs der instanzlosen Void()Fachfunktion eines Typs „A“ für einen weiteren Typ „B“, wie Codeauszug 24 zeigt. Deswegen ist Void kein Schlüsselwort der Sprache. Quellcodeauszug 01 String retVal = Boolean.Void(); // Semantikfehler! Codeauszug 24: Fehlerhafte Verwendung von Void() 42 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 4.8.2 Spezielle Fachfunktion der Klasse Boolean: Failed Eine Besonderheit stellt die Fachfunktion Failed der Klasse Isom.Base.Boolean dar. Diese Fachfunktion liefert nur true zurück, wenn das betreffende Boolean-Objekt false oder das Void-Objekt ist; anderenfalls liefert Failed false zurück. Die Fachfunktion Failed ist für den Einsatz bei der Fehlerbehandlung vorgesehen. Viele fachliche Funktionen haben per Konvention einen Rückgabewert vom Typ Isom.Base.Boolean; dabei wird im Erfolgsfall true und im Fehlerfall false zurückgeliefert. Durch einen Aufruf von Failed auf dem Rückgabewert können in einem solchen Fall sowohl Fehler, die die Fachfunktion selbst erkennt (Rückgabewert false), als auch unerwartete Ausnahmen (Rückgabe des Void-Objekts) abgefangen werden. Codeauszug 25 zeigt den Einsatz der Funktion Failed zur Fehlerbehandlung. Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 Boolean valFalse = false; Boolean valVoid = Boolean.Void(); if (valFalse.Failed ()) { // wird zu "true" ausgewertet, // da valFalse "false" ist // Fehlerbehandlung ... } if (valVoid.Failed ()) { // Fehlerbehandlung ... } // wird zu "true" ausgewertet, // da valVoid "Void" ist Codeauszug 25: Fehlerbehandlung mit Boolean.Failed 4.8.3 Fortpflanzung von Void Die meisten Fachfunktionen von ISOM/L-Objekten, die Eingabeparameter erwarten, kehren mit dem Void-Objekt als Rückgabewert zurück, falls der oder die Eingabeparameter ebenfalls das VoidObjekt sind. (Das Verhalten der einzelnen Fachfunktionen ist in der Dokumentation der ISOM/L-Bibliothek für Fachautoren [2] beschrieben.) Wird zum Beispiel der Fachfunktion Stdout der Klasse System (Namensraum Isom.Base, siehe auch Kapitel 2.1.6 und 6), die die 43 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München als Parameter übergebene Zeichenkette nebst einem zusätzlichen Zeilenumbruch auf dem Standardausgabestrom ausgibt, mit dem Void-Objekt als Parameter aufgerufen, unterbleibt die Ausgabe auf dem Standardausgabestrom vollständig. (In diesem Fall wird auch kein zusätzlicher Zeilenumbruch ausgegeben.) In ISOM/L-Programmen werden oftmals Fachfunktionsaufrufe verkettet, sodass Variablen, die Rückgabewerte früherer Funktionsaufrufe enthalten, als Eingabeparameter für nachfolgende dienen. Liefern diese Funktionsaufrufe ein Void-Objekt zurück, ist dieses Verhalten zu beachten. Codeauszug 26 zeigt ein Beispiel dazu, das drei Aufrufe der zuvor erwähnten Fachfunktion Stdout der Klasse System enthält. 44 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 /* * ISOM/L-Beispielprogramm: CheckVoid.is * Verkettung von Void-Rückgabewerten */ using Isom.Base.*; using Isom.Sys.*; namespace HelloWorld { Boolean main() { String msg = "Hello, "; // 'msg' definieren String name = String.Void(); // 'name' invalidieren 16 17 18 19 20 21 22 23 24 // 1. Aufruf von 'System.Stdout' System.Stdout(msg); // 'msg' ausgeben 25 26 27 28 29 30 31 32 33 34 35 // 3. Aufruf von 'System.Stdout' System.Stdout(msg); // 'msg' nochmals ausgeben return true; // 2. Aufruf von 'System.Stdout' // 'name' an 'msg' anhängen: // Anhängen von "Void" liefert "Void" als Rückgabewert; // Ausgabe von "Void" auf Stdout tut nichts System.Stdout(msg.Append(name)); } } Ausgabe: Hello, Hello, Codeauszug 26: CheckVoid.is und Ausgabe Das Ergebnis der Ausführung dieses Programms sind zwei (!) Zeilen auf der Standardausgabe, jeweils mit dem Inhalt Hello,. Der zweite von drei Aufrufen der Fachfunktion Stdout erhält als Eingabeparameter das Void-Objekt und kehrt daher sofort (ebenfalls mit Void als Rückgabewert, hier nicht weiter betrachtet) zurück, ohne eine Zeile auf der Standardausgabe auszugeben. Zusätzlich zu beachten ist, dass der Inhalt der Variablen msg durch das (notwendigerweise fehlgeschlagene) Anhängen des Void-Objekts nicht verändert wird, wie die zweite Ausgabe (der dritte Aufruf von System.Stdout) der Zeichenkette zeigt. 45 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 4.9 Containerklassen Mehrere ISOM-Objektinstanzen können in einem Containerobjekt zusammengefasst werden. Containerklassen in ISOM/L sind Listen und Wörterbücher. Typnamen von Listen enden auf …List (z.B. NumberList), Typnamen von Wörterbüchern auf …Dictionary (z.B. StringDictionary). Wenn für eine Klasse eine Containerklasse existiert, ist diese stets in demselben Namensraum definiert (z.B. String und StringList im Namensraum Isom.Base). Nachfolgend wird der grundlegende Umgang mit beiden Typen von Containerklassen beschrieben. Konkrete Containerklassen können, abhängig vom enthaltenen Typ, weitere Komfortfunktionen anbieten, über die eine andere konkrete Containerklasse nicht verfügt. 4.9.1 Listen Eine ISOM/L-Liste enthält eine geordnete Folge von Objektinstanzen desselben Typs („Elemente“). Ein Element kann mehrfach in derselben Liste enthalten sein. Elemente werden mit der Fachfunktion Insert() an das Ende der Liste angefügt. Es gibt grundsätzlich zwei Möglichkeiten, auf Elemente einer Liste zuzugreifen: Zugriff auf das Element an einer bestimmten Position in der Folge mit der Fachfunktion At() Iterieren über alle Elemente einer Liste mithilfe einer Schleife und der Fachfunktionen HasNext() und Next() Vor dem ersten Schleifendurchlauf sollte zudem die Fachfunktion Reset() aufgerufen werden. Reset() setzt die Position des internen Iterators vor den Listenanfang zurück. HasNext() bestimmt, ob die Liste noch mindestens ein weiteres Element hinter der aktuellen Iteratorposition enthält. Next() liefert dieses Element. Codeauszug 27 zeigt die Verwendung einer Liste von Zahlen. 46 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 /* * ISOM/L-Beispielprogramm: ExNumberList.is * Liste von Zahlen */ using Isom.Base.*; using Isom.Sys.*; namespace ExNumberList { Boolean main () { 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 } // Liste erzeugen NumberList list = NumberList.CreateNumberList(); // Liste mit Elementen befüllen list.Insert(3); list.Insert(42); list.Insert(3); list.Insert(-71); list.Insert(100.1); // Länge der Liste ermitteln und ausgeben String msg = "Die Liste enthält $length Elemente:"; Number length = list.Length(); msg.Replace("$length", length.ToIntString()); System.Stdout(msg); // Über Liste iterieren und alle Elemente ausgeben list.Reset(); // internen Iterator zurücksetzen while(list.HasNext()) /* solange noch nicht alle Elemente betrachtet wurden... */ { Number elem = list.Next(); // nächstes Element abrufen System.Stdout(elem.ToFloatString());// Fließkommadarstellung } return true; } Codeauszug 27: ExNumberList.is 47 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Hinweis: die Verwendung des „$“-Symbols am Anfang von Platzhaltern bei der Ersetzung von Zeichenketten mit Replace() ist frei gewählt und dient nur zur besseren Lesbarkeit des Quelltexts. Es könnte jede andere Zeichenkette ersetzt werden. 4.9.2 Wörterbücher Ein ISOM/L-Wörterbuch besteht aus einer Menge eindeutiger Schlüssel des Typs String und einer Menge von Werten eines Typs, wobei einem Schlüssel genau ein Wert zugeordnet ist. Ein UriDictionary bildet daher Schlüssel vom Typ String auf Werte vom Typ Uri ab. Ein Schlüssel-Wert-Paar wird mit der Fachfunktion Add(String key, <Typname> value) zu einem Wörterbuch hinzugefügt. Existiert der Schlüssel noch nicht im Wörterbuch, wird ein neuer Eintrag angelegt. Existiert er bereits, wird der Wert, der ihm zugeordnet ist, mit dem neuen Wert überschrieben. Ein Wert, der in einem Wörterbuch hinterlegt ist, kann über seinen eindeutigen Schlüssel mit der Fachfunktion Get(String key) abgerufen werden. Existiert dieser Schlüssel nicht, wird das Void-Objekt zurückgegeben. Um über alle Einträge in einem Wörterbuch zu iterieren, kann GetKeys () die Liste aller Schlüssel (Typ StringList) ermitteln. Danach kann er, wie in Kapitel 4.9.1 beschrieben, über alle Schlüssel in der Liste iterieren und für jeden Schlüssel mit Get(String key) den zugehörigen Wert abrufen. Codeauszug 28 zeigt ein Beispiel für die Verwendung eines Wörterbuchs von Zeichenketten. 48 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 /* * ISOM/L-Beispielprogramm: ExStringDictionary.is * Wörterbuch von Zeichenketten */ using Isom.Base.*; using Isom.Sys.*; namespace ExStringDictionary { Boolean main () { // Wörterbuch erzeugen StringDictionary dict = StringDictionary.CreateStringDictionary(); // Wörterbuch mit Schlüssel-Wert-Paaren befüllen dict.Add("Frankreich", "Paris"); dict.Add("Deutschland", "Berlin"); dict.Add("Australien", "Canberra"); // Anzahl der Schlüssel-Wert-Paare ermitteln und ausgeben String msg = "Das Wörterbuch enthält $count Schlüssel-Wert-Paare:"; Number count = dict.Count(); msg.Replace("$count", count.ToIntString()); System.Stdout(msg); // Über Liste von Schlüsseln iterieren und alle Paare ausgeben StringList keyList = dict.GetKeys(); keyList.Reset(); // internen Iterator zurücksetzen while(keyList.HasNext()) /* solange noch nicht alle * Elemente betrachtet wurden... */ { String key = keyList.Next(); // nächsten Schlüssel abrufen String value = dict.Get(key); msg = "Die Hauptstadt von $key ist $value"; msg.Replace("$key", key); msg.Replace("$value", value); System.Stdout(msg); } return true; } } Codeauszug 28: ExStringDictionary.is 49 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 4.10 Globale Variablen In ISOM/L können sogenannte globale Variablen definiert werden, die während einer Interpretersitzung aus allen Funktionen heraus abgerufen und manipuliert werden können. Eine globale Variable kann entweder vom Typ Number oder vom Typ String oder StringList sein. Sie wird durch eine Zeichenkette eindeutig bezeichnet. Die vorgenannten Klassen verfügen jeweils über folgende Fachfunktionen für globale Variablen: AddGlobal(String, <Number oder String>) erzeugt eine neue globale Variable mit dem übergebenen Bezeichner und Wert. Existiert bereits eine globale Variable mit diesem Bezeichner, wird der vorherige Wert ersetzt. GetGlobal(String) ruft den Wert der globalen Variablen mit dem übergebenen Bezeichner ab. Existiert kein solcher Bezeichner, wird das Void-Objekt zurückgegeben, anderenfalls eine Kopie des Variablenwerts. Änderungen an diesem Wert ändern den Wert der globalen Variable nicht (siehe auch Kapitel 4.2 ff.)! Um Änderungen an der globale Variable zu übernehmen, muss der geänderte Wert mit AddGlobal() wieder gesichert werden. RemoveGlobal(String) löscht die globale Variable mit dem übergebenen Bezeichner. Die Fachfunktion gibt genau dann true zurück, wenn eine globale Variable mit diesem Bezeichner existierte und entfernt werden konnte. GetExistingGlobals() schließlich liefert eine Liste von Zeichenketten, die alle bekannten Bezeichner globaler Variablen des Typs enthält, für den die Fachfunktion aufgerufen wurde. Die Klasse StringList verfügt zudem über die Fachfunktion AddStringToGlobalList(), die eine Zeichenkette zu einer in einer globalen Variablen gesicherten Zeichenkettenliste hinzufügt [2]. 50 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 4.11 ISOM/L-Bibliothek für Fachautoren Alle Klassen und Namensräume des ISOM-Objektmodells sind in [2] beschrieben. Das vorliegende Handbuch beschränkt sich auf die Klassen aus folgenden Namensräumen: 4.12 Isom.Base.* Isom.Sys.* Isom.Request.* Erweiterung der Klassen des ISOM-Objektmodells Die Klassen des ISOM-Objektmodells lassen sich in ISOM/L durch neue Fachfunktionen ergänzen. Bereits bestehende Fachfunktionen können überschrieben werden. Wird eine Fachfunktion überschrieben, muss die Fachfunktion, die sie überschreibt, die gleiche Funktionssignatur aufweisen, wie die Original-Fachfunktion, die überschrieben wird. Die neuen Fachfunktionen werden in einer ISOM/L-Quelldatei implementiert, in der kein Namensraum, sondern eine Erweiterung definiert wird. Eine Erweiterung wird durch das Schlüsselwort extension eingeleitet. Dateien, die eine Erweiterung enthalten, werden im anwenderspezifischen Verzeichnis \<OEM>\ISOM\isoml abgelegt. Der Name der Erweiterung setzt sich aus dem Namen des OEM und dem Namensraumbezeichner der erweiterten Klasse zusammen. Codeauszug 29 zeigt eine beispielhafte Erweiterung der Klasse Isom.Base.String. Erweiterungen erlauben die Definition instanzloser und instanzgebundener Fachfunktionen. Sie werden durch das Schlüsselwort objectbound unterschieden: Wird objectbound angegeben, benötigt der Aufruf der Fachfunktion eine Objektinstanz. Diese Objektinstanz ist in der Implementierung der Fachfunktion durch das Schlüsselwort this verfügbar. Ohne objectbound ist die Fachfunktion instanzlos und kann ohne Objektinstanz aufgerufen werden. In instanzlosen Fachfunktionen kann this daher nicht benutzt werden. Wird eine Fachfunktion überschrieben, kann die originale Fachfunktion auch weiterhin verwendet werden. Dazu ruft man die 51 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Funktion mit dem Schlüsselwort base auf. Dies ist auch innerhalb der überschreibenden Fachfunktion möglich. Quellcodeauszug 01 using Isom.Base.*; 02 using Isom.Sys.*; 03 04 // Erweiterung der Klasse "Isom.Base.String" 05 extension Didact.Isom.Base.String 06 { 07 08 09 10 11 12 13 14 15 // Erweiterung mit einer neuen instanzgebundenen Fachfunktion objectbound Boolean StartsWith(String startString) { Number length = startString.Length(); 16 17 18 19 20 21 22 23 // Erweiterung mit einer neuen instanzlosen Fachfunktion String GetSpaces(Number count) { String result = ""; Number index = count; // Beenden der Schleife, sobald "index" gleich 0 while(index.Gt(0)) { 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 // Zugriff auf "this" zum Vergleich mit dem Übergabeparameter return this.Substring(0, length).Equals(startString); } // Anhängen eines Leerzeichens result = result.Append(" "); // Erniedrigen des Index um 1 index = index.Sub(1); } return result; } // Überschreiben einer instanzgebundenen Fachfunktion, // die in der Basisklasse "Isom.Base.String" bereits definiert ist objectbound Number ParseNumber() { // Ersetzen von Kommas durch Punkte, z.B. wird "1,5" zu "1.5" // Zugriff auf "this" String formatted = this.Replace(",", "."); // Aufruf der Original-Fachfunktion mit "base" return formatted.base.ParseNumber(); } // Überschreiben einer instanzlosen Fachfunktion, // die in der Basisklasse "Isom.Base.String" bereits definiert ist Boolean AddGlobal(String key, String value) { 52 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 47 48 49 50 String msg = "Hinzugefügt: Variable "; msg.Append(key); // Ausgabe auf der Kommandozeile System.Stdout(msg); 51 52 53 54 } // Aufruf der Original-Fachfunktion mit "base" return base.AddGlobal(key, value); } Codeauszug 29: Erweiterung von Isom.Base.String 53 von 109 4 Grundlagen des ISOM/L-Objektmodells Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 5 Strukturierung von ISOM/L-Programmen ISOM/L-Programme sind Textdateien im Freiformat. Es wird empfohlen, als Zeichencodierung UTF-8 zu verwenden. Ihre Dateierweiterung lautet .is. Achtung: Ein ISOM/L-Programm muss sich in einem Verzeichnis befinden, das dem Namensraum entspricht, der im Programm definiert ist, relativ zum korrekten ISOM/L-Klassenverzeichnis (siehe Kapitel 5.1), wenn der Namensraum von anderen Namensräumen aus referenzierbar sein soll. Ein Programm, dessen main-Funktion im ISOM-Kommandozeilenmodus (siehe Kapitel 8.1) aufgerufen werden soll, kann sich an einem beliebigen Ort befinden. Eine gültige ISOM/L-Programmdatei besteht aus: einer beliebigen Anzahl (auch null möglich) von usingAnweisungen, gefolgt von beliebig vielen anonymen Namensräumen, gefolgt von höchstens einer Namensraumdefinition Codeauszug 30 zeigt ein Beispiel eines vollständigen ISOM/LProgramms. 54 von 109 5 Strukturierung von ISOM/L-Programmen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 /* * ISOM/L-Beispielprogramm: Fibonacci.is * Berechnung der Fibonacci-Folge von 0 bis 10 */ using Isom.Base.*; using Isom.Sys.*; namespace Fibonacci { deftext MESSAGE MSG_FIBO "Die Fibonacci-Folge von 0 bis 10 lautet: " // Berechnet die n-te Fibonacci-Zahl Number Fibo (Number n) { if (n.Eq (0)) return 0; if (n.Eq (1)) return 1; Number Number Number Number return n1 = n.Sub (1); n2 = n.Sub (1); a = Fibo (n1); b = Fibo (n2); a.Add (b); } Boolean main () { String msg = MSG_FIBO; String sep = ", "; Number index = 0; while (index.Lt (10)) { Number num = index; msg.Append (Fibo (num).ToIntString ()); msg.Append (sep); index.Add (1); } msg.Append (Fibo (index).ToIntString ()); System.Stdout (msg); return true; } } Codeauszug 30: Fibonacci.is 55 von 109 5 Strukturierung von ISOM/L-Programmen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Hinweis: ISOM unterstützt die Zeichencodierungen UTF-8 und ISO-8859-1 ohne Bytereihenfolgenmarkierung sowie UTF-8 und UTF-16 mit Bytereihenfolgenmarkierung. Der Präprozessor konvertiert Quelldateien mit anderen Zeichencodierungen als UTF-8 intern vor der weiteren Verarbeitung in UTF-8, so dass eine Mischung von Quelldateien verschiedener Zeichenkodierungen unterstützt wird. Wird jedoch versucht, andere Zeichenkodierungen zu verwenden, zum Beispiel Windows-1252, erfolgt die Umwandlung unter der inkorrekten Annahme, es würden Quellen in ISO-8859-1 vorliegen. Dies kann zu beschädigten Zeichen führen. 5.1 Hierarchische Struktur von Namensräumen Namensraumbezeichner sind hierarchisch strukturiert. Die einzelnen Teile werden durch Punkte („.“) voneinander getrennt. Codeauszug 31 zeigt Beispiele für zulässige Namensraumbezeichner. Quellcodeauszug 01 02 03 04 Isom.Base.Number Isom.Global.Processes Oem.G42.D_ACC Test Codeauszug 31: Beispiele für gültige Namensraumbezeichner Der letzte Teil eines Namensraumbezeichners stellt den Typnamen dar. Der Teil des Namensraumbezeichners vor dem Typnamen (und ohne den Punkt vor dem Typnamen) wird Grundraumbezeichner genannt. Der gesamte Namensraumbezeichner wird auch als „vollqualifizierter Typname“ bezeichnet. Die Namensraumbezeichner müssen der Datei- und Verzeichnisstruktur der ISOM/L-Programme entsprechen. Jeder Namensraum muss in einer eigenen Quelldatei abgelegt sein. Um ein bestimmtes Programm zu finden, verfährt die ISOM-Laufzeitumgebung wie folgt: Zuerst wird nach einem Verzeichnis gesucht, das dem vollqualifizierten Typnamen entspricht. In diesem Verzeichnis wird das eigentliche Programm gesucht. Der Name der Datei entspricht dem Typnamen, ergänzt durch die Erweiterung .is. Sollte es diese Datei nicht geben, wird im Verzeichnis, das dem Grundraumbezeichner entspricht, nach der Datei gesucht. Auch in diesem Fall muss der Dateiname dem Typnamen mit angehängtem .is entsprechen. Jedes Programm kann nur einen einzigen nicht-anonymen Namensraum enthalten. Die Verzeichnisstrukturen sind relativ zum Wurzelverzeichnis der ISOM/L-Programme. Abbildung 2 visualisiert den Suchalgorithmus als Flussdiagramm. 56 von 109 5 Strukturierung von ISOM/L-Programmen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Abbildung 2: Finden von Programmen 5.2 Die Importanweisung Innerhalb von selbst definierten Funktionen können auch Funktionen und Textdefinitionen anderer Namensräume verwendet werden. Das Gleiche gilt für Objektinstanzen von Klassen, die von ISOM bereitgestellt werden. Dabei gibt es zwei Möglichkeiten: Generell können alle Typen immer verwendet werden, indem ihr vollqualifizierter Typname als Typbezeichner verwendet wird. Alternativ kann der Programmierer auch mit dem Schlüsselwort using den Import anderer Typen anweisen. 57 von 109 5 Strukturierung von ISOM/L-Programmen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Vor der Definition eines Namensraums können beliebig viele Importanweisungen stehen. Diese bestehen aus dem Schlüsselwort using, gefolgt vom vollqualifizierten Typnamen des zu importierenden Typs und einem Semikolon („;“). Der zu importierende Typ kann sowohl eine von ISOM/L bereitgestellte Klasse als auch ein von einem Programmierer definierter Namensraum sein. Anstelle des Typnamens kann auch ein „*“ stehen. In diesem Fall werden alle Typen mit dem entsprechenden Grundraumbezeichner importiert. Codeauszug 32 zeigt einige Beispiele für Importanweisungen. Quellcodeauszug 01 02 03 04 using using using using Isom.Base.Boolean; Isom.Base.String; Isom.Base.Number; Isom.Sys.*; Codeauszug 32: Beispiele für Importanweisungen Zur Verwendung der importierten Typen ist der einfache Typname als Typbezeichner ausreichend, wenn Verwechslungen ausgeschlossen sind. Dies ist nicht der Fall, wenn mehrere Typen mit unterschiedlichen Grundraumbezeichnern, aber demselben Typnamen importiert worden sind. In diesem Fall muss trotz vorangegangener using-Anweisung der vollqualifizierte Typname als Typbezeichner verwendet werden. Zur Verwendung von Funktionen und Textbezeichnern, die in anderen Namensräumen deklariert sind, muss immer der betreffende Typname, gefolgt von einem Punkt („.“), der jeweiligen Funktion bzw. dem Textbezeichner vorangestellt werden. Das Gleiche gilt für den Aufruf instanzloser Fachfunktionen einer Klasse. Wie oben beschrieben, kann der vorangestellte Typname entweder der vollqualifizierte Typname oder, wenn der betreffende Namensraum importiert wurde und Verwechslungen ausgeschlossen sind, der Grundraumbezeichner sein. Die Verwendung fremder Funktionen oder Textbezeichner ohne vorangestellten Typnamen ist nicht zulässig, da ISOM in diesem Fall die Funktion bzw. den Textbezeichner im eigenen Namensraum suchen würde. 5.3 Übersetzbare Texte und Textdefinitionen ISOM/L bietet die Möglichkeit, Bezeichner für übersetzbare Texte zu definieren. Diese Textbezeichner können anschließend in ISOM/L-Programmen anstelle von Zeichenkettenliteralen verwendet werden. Der Begriff „übersetzbar“ bedeutet hier, dass ISOM beim Verarbeiten der Programme eine Liste erstellt, die 58 von 109 5 Strukturierung von ISOM/L-Programmen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München sämtliche definierten Textbezeichner mit den zugehörigen Texten enthält. Ein geeignetes Werkzeug kann daraufhin alle Texte extrahieren und bisher unbekannte Texte zur Übersetzung in alle verwendeten Sprachen anweisen. Jedem Textbezeichner wird eine Kategorie zugewiesen, abhängig davon, in welchem Kontext der betreffende Text innerhalb des Programms verwendet werden soll. Die zulässigen Kategorien kann der Programmierer in der Datei TextCategoryData.xml festlegen, die sich im OEM-spezifischen Verzeichnis \<OEM>\ISOM\isoml befindet. Codeauszug 33 zeigt den Aufbau dieser Datei. Quellcodeauszug 01 <?xml version="1.0" encoding="utf-8" ?> 02 <TextCategoryData 03 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 04 xsi:noNamespaceSchemaLocation="TextCategoryData.xsd"> 05 <TextCategory>INTERNAL</TextCategory> 06 <TextCategory>ACTION</TextCategory> 07 <TextCategory>ECU</TextCategory> 08 <TextCategory>PROGRESS</TextCategory> 09 <TextCategory>REPORT</TextCategory> 10 <TextCategory>TITLE</TextCategory> 11 <TextCategory>MESSAGE</TextCategory> 12 <TextCategory>HINT</TextCategory> 13 <TextCategory>OPTION</TextCategory> 14 <TextCategory>BUTTON</TextCategory> 15 <TextCategory>ACK_BUTTON</TextCategory> 16 <TextCategory>CONT_BUTTON</TextCategory> 17 <TextCategory>CONT_ACK_BUTTON</TextCategory> 18 <TextCategory>BACK_BUTTON</TextCategory> 19 <TextCategory>BACK_ACK_BUTTON</TextCategory> 20 <TextCategory>ERRORTEXT</TextCategory> 21 </TextCategoryData> Codeauszug 33: Beispiel für Datei TextCategoryData.xml Textdefinitionen sind Bestandteil eines Namensraums und werden am Anfang des Namensraums vor den Funktionsdefinitionen definiert. Dort können beliebig viele (auch null) Textdefinitionen stehen. Eine Textdefinition besteht aus dem Schlüsselwort deftext, gefolgt vom Bezeichner der Kategorie und dem Textbezeichner selbst. Dem schließt sich der eigentliche Text in der Referenzsprache der Serviceorganisation an. Dieser Text ist ein Zeichenkettenliteral, wie in Kapitel 4.2 beschrieben. Codeauszug 34 zeigt Beispiele für Textdefinitionen. 59 von 109 5 Strukturierung von ISOM/L-Programmen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 deftext BUTTON BUTTON_OK "OK" 02 deftext MESSAGE MSG_OUTPUT_FINISHED "Ausgabe " \ 03 "ist erfolgt." Codeauszug 34: Beispiele für Textdefinitionen 5.4 Einfügen von Dateien in ISOM/L-Quellen Um die Lesbarkeit und Wartbarkeit großer Programme zu verbessern, besteht eine Möglichkeit, die Länge von Programmen zu reduzieren: Man kann Teile des ISOM/L-Quelltexts auslagern und durch eine Anweisung an einer bestimmten Stelle eines Programms einfügen. Die auf diese Weise ausgelagerten Quelltextteile können sich in verschiedenen Dateien befinden. Sie werden vor der Verarbeitung durch den Interpreter von einem Präprozessor zusammengefügt. Es besteht die Möglichkeit, Namensräume ohne Bezeichner zu definieren (sogenannter anonymer Namensraum). Folgt in einem ISOM/L-Programm auf einen oder mehrere solcher anonymen Namensräume ein Namensraum mit einem Bezeichner, interpretiert ISOM die in dem/den anonymen Namensräumen definierten Funktionen so, als ob sie direkt zum „eigentlichen“ Namensraum gehörten. Die Dateiendung der ausgelagerten Quelltextteile lautet .isi. Sie können über die Präprozessordirektive #include unter Angabe des Pfads relativ zum Basisverzeichnis der Programme eingebunden werden. Codeauszug 35 zeigt, wie ein ausgelagerter Teil des Quelltexts eingebunden wird. Quellcodeauszug 01 #include "Oem/G42/Retrofit/SteeringWheelRetrofit.isi" Codeauszug 35: Einbinden ausgelagerter Quelltextteile Der Vorteil besteht darin, dass die Länge der Programme reduziert werden kann. Auf diese Weise wird die Lesbarkeit und Wartbarkeit großer Programme verbessert und die Möglichkeit der Wiederverwendung eröffnet. 60 von 109 5 Strukturierung von ISOM/L-Programmen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 6 Ein- und Ausgabe Ein- und Ausgabe von Daten gehören zu den Grundaufgaben jeder Programmiersprache. Das vorliegende Kapitel zeigt, wie mit ISOM/L Datenströme und Dateien verarbeitet werden können und erklärt die ISOM/L-Klassen zur Interaktion mit Benutzern an der Bedienoberfläche. 6.1 Standard-Datenströme Die Klasse Isom.Sys.System stellt Fachfunktionen zur Manipulation der Standardeingabe, der Standardausgabe und der Standardfehlerausgabe bereit (siehe auch das einführende Kapitel 2). Codeauszug 36 zeigt die Verwendung der Fachfunktionen. Ihr Einsatz ist nur im ISOM-Kommandozeilenmodus sinnvoll. 61 von 109 6 Ein- und Ausgabe Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 /* * ISOM/L-Beispielprogramm: Stdio.is * Verwendung der Standard-Datenströme */ using Isom.Sys.*; using Isom.Base.*; namespace Stdio { Boolean main () { // Meldung auf Standardausgabe schreiben System.Stdout("Bitte geben Sie Ihren Namen ein: "); 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 } // Zeichenkette von Standardeingabe lesen String name = System.Stdin(); if(name.Length().Gt(0)) { // Meldung auf Standardausgabe schreiben String greeting = "Hallo, "; greeting.Append(name); System.Stdout(greeting); } else { // Fehler: kein Name eingegeben // Fehlermeldung auf Standardfehlerausgabe schreiben System.Stderr("Kein Name eingegeben"); return false; } return true; } Codeauszug 36: Stdio.is 62 von 109 6 Ein- und Ausgabe Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 6.2 Dateizugriff ISOM/L wurde mit dem Ziel entworfen, Serviceprozesse auf einfache Art und Weise definieren zu können. Daher ist ISOM/L auf diesen Anwendungsbereich zugeschnitten und nicht als Allzweckprogrammiersprache zu verstehen. Auch aus Gründen der Prozesssicherheit der Serviceanwendung, deren Abläufe in ISOM/L definiert werden, erhält der Programmierer keinen vollständigen Zugriff auf das Dateisystem des ausführenden Rechners. Dennoch bietet ISOM/L grundlegende Funktionalität zum Manipulieren von Dateien an. 6.2.1 Die Klasse Isom.Base.Data Ausgangspunkt für Dateioperationen sind die Fachfunktionen der Klasse Isom.Base.Data. Die Klasse unterstützt das Lesen und Schreiben von Daten im XML-Format. Als Sonderfall können formatfreie Textdateien eingelesen werden. Der Speicherort der zu manipulierenden Dateien muss vom Programmierer als URI angegeben werden. ISOM/L bietet dazu die Klasse Isom.Base.Uri an. Sie ist in [2] beschrieben. Codeauszug 37 zeigt das Einlesen einer Textdatei. 63 von 109 6 Ein- und Ausgabe Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 /* * ISOM/L-Beispielprogramm: OutputText.is * Liest eine Textdatei ein und * gibt sie auf der Standardausgabe aus */ using Isom.Base.*; using Isom.Sys.*; namespace OutputText { Boolean main () { 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 /* Speicherort der Datei - hier Index-Datei der IFS-Webpräsenz; * kann auch Datei auf lokalem Dateisystem * (URI beginnt mit "file://...") sein */ String fullPath = "http://www.ifs-it.de/index.htm"; Uri uri = Uri.DefineUri(fullPath); 29 30 31 32 33 34 35 36 37 38 39 40 41 } // Dateiinhalt (= Text) aus Datenobjekt extrahieren String text = data.GetText(); if(text.IsVoid()) // Extraktion erfolgreich? { System.Stderr("Text konnte nicht extrahiert werden"); return false; } // HTML-Datei wie eine formatfreie Textdatei laden Data data = Data.LoadText(uri); if(data.IsVoid()) // Laden erfolgreich? { System.Stderr("Laden der Datei nicht erfolgreich"); return false; } // Inhalt ausgeben System.Stdout(text); return true; } Codeauszug 37: OutputText.is Wie bereits erwähnt, unterstützt Isom.Base.Data nur das Schreiben von Daten im XML-Format. Die mit den Fachfunktionen von Isom.Base.Data erzeugten „XML-Dateien“ können mit Isom.Base.Data wieder geladen werden. Das Laden beliebiger XML-Dateien anderen Ursprungs (d.h. die nicht mit 64 von 109 6 Ein- und Ausgabe Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Isom.Base.Data erzeugt wurden) wird dagegen nicht unterstützt. Codeauszug 38 zeigt das Schreiben von XML-Dateien. Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 /* * ISOM/L-Beispielprogramm: WriteXml.is * Schreibt eine XML-Datei */ using Isom.Base.*; using Isom.Sys.*; namespace WriteXml { Boolean main () { // XML-Struktur erzeugen Data dataNodeA = Data.Create("NodeA"); // Datenelement A erzeugen Data dataNodeB = Data.Create("NodeB"); // Datenelement B erzeugen dataNodeB.SetText("Text"); dataNodeA.AddElement(dataNodeB); // B als Kindknoten von A setzen // Speicherort der Datei String fullPath = "file://C:/temp/test.xml"; Uri uri = Uri.DefineUri(fullPath); // XML-Struktur in Datei schreiben Boolean result = dataNodeA.WriteXml(uri); if(result.Failed()) // Schreiben fehlgeschlagen { System.Stderr("Datei konnte nicht gespeichert werden"); return false; } return true; } } Codeauszug 38: WriteXml.is Führt man das Programm in Codeauszug 38 aus, entsteht folgende XML-Datei am angegebenen Ort: Quellcodeauszug 01 <?xml version="1.0" encoding="utf-8"?> 02 <NodeA> 03 <NodeB>Text</NodeB> 04 </NodeA> Codeauszug 39: Ergebnis der Ausführung von Codeauszug 38 65 von 109 6 Ein- und Ausgabe Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Das Vorgehen, um diese XML-Datei wieder einzulesen, zeigt Codeauszug 40. Alle Fachfunktionen der Klasse Isom.Base.Data sind in [1] beschrieben. Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 /* * ISOM/L-Beispielprogramm: LoadXml.is * Liest eine XML-Datei */ using Isom.Base.*; using Isom.Sys.*; namespace LoadXml { Boolean main () { 14 15 16 17 // Speicherort der Datei String fullPath = "file://C:/temp/test.xml"; Uri uri = Uri.DefineUri(fullPath); 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 } // XML-Struktur laden Data xml = Data.LoadXml(uri); if(xml.IsVoid()) // Laden fehlgeschlagen { System.Stderr("Datei konnte nicht geladen werden"); return false; } // innerhalb der XML-Struktur navigieren DataList childNodes = xml.FindElements("B"); // ... ggf. weitere Operationen ... return true; } Codeauszug 40: LoadXml.is 66 von 109 6 Ein- und Ausgabe Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 7 Bedienoberfläche und Benutzerinteraktion ISOM/L stellt im Namensraum Isom.Request Klassen zur Anzeige von Bedienelementen zur Interaktion mit den Benutzern eines Programms zur Verfügung. Das vorliegende Kapitel beschreibt die Konzepte, die den Klassen des Namensraums Isom.Request zugrunde liegen. Da die konkrete Gestaltung der Bedienoberfläche der jeweiligen Anwendung vorbehalten ist, sind die Klassen und ihre Fachfunktionen bewusst allgemein gehalten. Annahmen über die grafische Darstellung und Anordnung von Bedienelementen an der Oberfläche werden allgemein nicht gemacht und diese lassen sich auch nicht über ISOM/L beeinflussen. Der Programmierer steuert lediglich das Anzeigen und Abräumen von Fenstern. ISOM/L stellt zwei Konzepte für die Benutzerinteraktion zur Verfügung: Dialogfenster (Klasse Isom.Request.UserRequest) zeigen ein einzelnes Fenster an der Bedienoberfläche an, das mit Hinweistexten, Auswahlgruppen, Schaltflächen usw. befüllt werden kann. Dialogfenster können blockierend und nichtblockierend angezeigt werden. Assistenten (Klasse Isom.Request.Wizard) bestehen aus einer Folge von Dialogschritten. Aufgabe der Dialogschritte ist das Einsammeln von Daten, die in einem abschließenden Schritt verarbeitet werden. Eine teilweise Verarbeitung kann aber auch bereits vor dem abschließenden Schritt erfolgen, unter Umständen sogar unumkehrbar. Der Assistent unterstützt den Bediener bei der Eingabe von Daten und ermöglicht auch das Vor- und Zurückbewegen zwischen Dialogschritten, sofern keine unumkehrbaren Aktionen ausgeführt wurden. Das Grundprinzip aller Klassen zur Benutzerinteraktion ist das der Containerklassen, die in Kapitel 4.9 beschrieben wurden: Instanzen von Bedienelementen eines Typs werden in einem Containerobjekt zusammengefasst, das selbst wiederum als Element zu einem Dialogfenster oder Assistenten hinzugefügt werden kann. 67 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 7.1 Darstellung der Bedienoberfläche im Kommandozeilenmodus Dialogfenster und Assistenten werden im Kommandozeilenmodus vom ISOM-Interpreter grafisch dargestellt, d.h. zur Darstellung werden separate Fenster geöffnet. Voraussetzung dazu ist, dass der ISOM-Interpreter mit der Kommandozeilenoption -Gui gestartet wird. In der in Kapitel 8.1 beschriebenen Testumgebung ist diese bereits voreingestellt. 7.2 Identifikationsnummern und Schlüssel Instanzen von Dialogfenstern und Assistenten sowie der darin enthaltenen Bedienelemente werden, wie in ISOM/L üblich, über entsprechende Create...-Fachfunktionen erzeugt. Das bereits erwähnte Containerprinzip macht es erforderlich, dass der Programmierer alle Elemente in einem Container (d.h. Anzeigeelement) eindeutig identifizieren kann. Das Ablaufsystem vergibt selbstständig eindeutige Identifikationsnummern (ID) für alle neu erstellten Dialogfenster und Assistenten. Sie können über die Fachfunktion GetId() für jede Instanz abgerufen werden. Dies ist nützlich, um alle gleichzeitig geöffneten Fenster aus Sicht des Programmierers unterscheiden zu können. Darüber hinaus kann es hilfreich sein, ihre IDs als globale Variablen zu speichern (siehe Kapitel 4.10), um Fenster funktionsübergreifend verwalten zu können. 68 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 /* * ISOM/L-Beispielprogramm: ExUserRequest.is * Dialogfenster und IDs */ using Isom.Base.*; using Isom.Sys.*; using Isom.Request.*; namespace ExUserRequest { deftext TITLE TITLE_USER_REQUEST "Dialogfenster" deftext INTERNAL USER_REQUEST_KEY "USER_REQUEST_ID" Number CreateNewRequest() { 18 19 20 21 22 23 24 25 26 /* Dialogfenster mit Textbezeichner TITLE_USER_REQUEST * als Titel erzeugen; Fenster enthält keine Bedienelemente */ UserRequest request = UserRequest.Create(TITLE_USER_REQUEST); // ID ermitteln Number id = request.GetId(); // ID global mit Schlüssel USER_REQUEST_ID ablegen, // um sie später aus anderen Namensräumen und/oder // Funktionen heraus abrufen zu können Number.AddGlobal(USER_REQUEST_KEY, id); 27 28 29 30 31 32 33 34 35 // ID zurückgeben und Funktion verlassen return id; } Boolean main () { // Funktion "CreateNewRequest" aufrufen CreateNewRequest(); 36 37 // ... weitere Programmschritte ... 38 39 40 41 // global gespeicherte ID des Diaglogfensters ermitteln Number id = Number.GetGlobal(USER_REQUEST_KEY); if(id.IsVoid().Not()) { 42 43 44 45 46 47 48 69 von 109 7 Bedienoberfläche und Benutzerinteraktion // Dialogfenster mit dieser ID holen UserRequest req = UserRequest.GetRequest(id); if(req.IsVoid().Not()) { req.ShowRequest(); // Dialogfenster anzeigen System.Wait(5000); // fünf Sekunden warten req.Dispose(); // Dialogfenster entfernen Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 49 50 51 52 53 54 } } } return true; } Codeauszug 41: ExUserRequest.is Im Unterschied zu den Dialogfenstern vergibt ISOM für die Bedienelemente innerhalb der Dialogfenster und Assistenten selbsttätig keine identitätsstiftenden Bezeichner. Diese müssen vielmehr beim Aufruf der entsprechenden Create...Fachfunktion als sogenannte Schlüssel vom Programmierer übergeben werden. Beispiele sind in Kapitel 7.3 zu finden. Führt man das in Codeauszug 41 enthaltene Programm aus, erscheint für fünf Sekunden ein leerer Dialog, wie in Abbildung 3 gezeigt. Abbildung 3: Leeres Dialogfenster 70 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 7.3 Bedienelemente ISOM/L bietet folgende Arten von Bedienelementen, die zu Dialogfenstern oder Assistenten hinzugefügt werden können: Bedienelement Typ im Namensraum Isom.Request Kurzbeschreibung Schaltfläche Button anklickbare Schaltfläche Anzeigetexte MessageElement Anzeigetexte für Hinweise oder Eingabeaufforderungen Auswahlgruppen SelectionGroup Auswahlgruppen in verschiedenen Ausprägungen: Mehrfachauswahl („check boxes“) Exklusivauswahl („radio buttons“) Mehrfachauswahlliste („list box“) Exklusivauswahlliste („drop down list“) Auswahlgruppen fassen OptionsObjekte zusammen. Option Option einzelnes Element einer Auswahlgruppe Medienelement MediaElement Medienobjekt, das z.B. einen Verweis auf eine Grafik oder ein Video enthalten kann Messwerte MeasuredValue stellt in Echtzeit erfasste Messwerte (z.B. Spannung) dar Tabelle 1: Arten von Bedienelementen Die Fachfunktionen dieser Klassen sind in [1] vollständig beschrieben. Außerdem existieren Containerklassen, um mehrere Objektinstanzen zusammenzufassen (siehe Kapitel 4.9), die in Tabelle 1 nicht aufgeführt sind. Codeauszug 42 erweitert die Funktion CreateNewRequest() in Codeauszug 41 um mehrere Bedienelemente und unterstreicht das Konzept der Containerklassen. Das vollständige Beispiel ist wie alle in diesem Handbuch dargestellten Beispiele im Verzeichnis Taurus\ISOM\doc\samples enthalten. 71 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 Number CreateNewRequest() 02 { 03 // Liste von Auswahlgruppen erzeugen 04 SelectionGroupList selectionGrpList = 05 SelectionGroupList.CreateSelectionGroupList(); 06 // Exklusivauswahl mit Schlüssel "Key_Color" erzeugen 07 SelectionGroup radio = 08 SelectionGroup.CreateRadioButtons("Key_Color"); 09 10 11 12 13 14 15 16 17 18 19 // drei Optionen erzeugen und zur Auswahlgruppe hinzufügen radio.AddOption(Option.CreateOption("Key_Red", OPTION_RED)); radio.AddOption(Option.CreateOption("Key_Green", OPTION_GREEN)); radio.AddOption(Option.CreateOption("Key_Blue", OPTION_BLUE)); // Überschrift hinzufügen radio.SetHeading(COLOR); // Option mit dem Schlüssel "Key_Blue" vorauswählen radio.Select("Key_Blue"); // zu Liste von Auswahlgruppen hinzufügen selectionGrpList.AddSelectionGroup(radio); 20 21 // Liste von Schaltflächen erzeugen ButtonList buttonList = ButtonList.CreateButtonList(); 22 23 24 25 26 // Schaltflächen erzeugen und zu Liste hinzufügen buttonList.AddButton(Button.CreateButton("Key_OK", BUTTON_OK)); buttonList.AddButton( Button.CreateButton("Key_Cancel", BUTTON_CANCEL)); 27 28 // Liste von Anzeigetexten erzeugen MessageList msgList = MessageList.CreateMessageList(); 29 30 31 32 33 34 35 36 37 38 39 40 41 // Hinweistext erzeugen und zu Liste hinzufügen msgList.AddMessage( MessageElement.CreateMessage("Key_Msg", MSG_SELECT_COLOR)); 42 43 44 45 46 47 48 } // ID ermitteln Number id = request.GetId(); // ID global mit Schlüssel USER_REQUEST_KEY ablegen Number.AddGlobal(USER_REQUEST_KEY, id); // ID zurückgeben und Funktion verlassen return id; /* Dialogfenster mit Textbezeichner TITLE_USER_REQUEST * als Titel erzeugen; Fenster enthält keine Bedienelemente */ UserRequest request = UserRequest.Create(TITLE_USER_REQUEST); // Liste von Auswahlgruppen zu Dialogfenster hinzufügen request.SetSelectionGroups(selectionGrpList); request.SetButtons(buttonList); request.SetMessages(msgList); Codeauszug 42: ExUserRequest2.is, CreateNewRequest() 72 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Führt man das in Codeauszug 42 enthaltene Programm aus, erscheint ein Dialogfenster mit Bedienelementen, siehe Abbildung 4. Abbildung 4: Dialogfenster mit Bedienelementen 7.4 Auswertung von Benutzereingaben Bislang wurde das erstellte Dialogfenster während einer festen Zeitspanne angezeigt und danach entfernt. Die Eingaben des Bedieners (falls während dieser Zeitspanne Eingaben getätigt wurden) wurden ignoriert. Um ein blockierendes Dialogfenster anzuzeigen, das so lange nicht verschwindet, bis der Bediener eine der enthaltenen Schaltflächen angeklickt hat, muss statt der Fachfunktion ShowRequest die Fachfunktion WaitUserRequest() verwendet werden. Ein Aufruf dieser Fachfunktion kehrt erst nach Anklicken einer Schaltfläche zurück. Rückgabewert ist die angeklickte Schaltfläche selbst. Anhand dieser kann der Programmierer feststellen, ob der Bediener zum Beispiel „OK“ oder „Abbruch“ gewählt hat, und entsprechend reagieren. 73 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Die Auswertung der Benutzereingaben für weitere Bedienelemente wie zum Beispiel Auswahlgruppen erfolgt ebenfalls nach dem Containerklassenprinzip in umgekehrter Reihenfolge des Hinzufügens: der Programmierer wählt zunächst ein Dialogfenster, ermittelt dessen Bedienelemente (die anhand ihrer Schlüssel eindeutig identifizierbar sind) und ruft schließlich die Eingaben des Benutzers bzw. die von ihm ausgewählten Optionen ab. Abschließend wird das Fenster durch Aufruf von Dispose() entfernt. Mit dem Aufruf von Dispose() verlieren auch alle im Dialogfenster enthaltenen Objekte (wie Auswahlgruppen) ihre Gültigkeit, d.h. Ergebnisse müssen vor einem Aufruf von Dispose() ausgewertet werden. Codeauszug 43 baut auf Codeauszug 41 und Codeauszug 42 auf und erweitert die main-Funktion um die Auswertung der Eingaben, die der Bediener tätigt. Das erscheinende Dialogfenster entspricht dem in Abbildung 4. 74 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 Boolean main () 02 { 03 // Funktion "CreateNewRequest" aufrufen 04 CreateNewRequest(); 05 06 // global gespeicherte ID des Diaglogfensters ermitteln 07 Number id = Number.GetGlobal(USER_REQUEST_ID); 08 if(id.IsVoid().Not()) 09 { 10 // Dialogfenster mit dieser ID holen 11 UserRequest req = UserRequest.GetRequest(id); 12 if(req.IsVoid().Not()) 13 { 14 15 16 17 18 19 20 21 22 23 24 25 26 // Dialogfenster blockierend anzeigen Button selected = req.WaitUserRequest(); // Schlüssel der gewählten Schaltfläche ermitteln String selectedKey = selected.GetKey(); if (selectedKey.Equals("Key_Cancel")) { // Benutzer hat "Abbruch" gewählt req.Dispose(); // Dialogfenster entfernen return true; } else // Benutzer hat OK gewählt { 27 28 29 30 // Ausgewählte Farbe ermitteln SelectionGroup selGrp = req.GetSelectionGroups().FindByKey("Key_Color"); 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 /* in einer exklusiven Auswahl kann nur eine Option * ausgewählt worden sein */ String key = selGrp.GetSelectedKeys().At(0); String msg = "Farbe $color wurde ausgewählt"; String color = ""; switch(key) { case "Key_Red": color = OPTION_RED; case "Key_Green": color = OPTION_GREEN; case "Key_Blue": color = OPTION_BLUE; default: { System.Stderr("Fehler bei der Farbauswahl"); return false; } 75 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 49 50 51 52 53 54 55 56 57 58 } } req.Dispose(); // Dialogfenster entfernen msg.Replace("$color", color); System.Stdout(msg); } } } return true; Codeauszug 43: ExUserRequest3.is, erw. main()-Funktion 7.5 Assistenten Die Klasse Isom.Request.Wizard unterstützt die Erstellung von Assistenten. Sie bietet dazu u.a. Fachfunktionen an, mit denen sich der Textinhalt und die Funktionalität von Schaltflächen jedes Schritts in der Dialogfolge angeben lassen. Gestartet wird die Anzeige des Assistenten mit der Fachfunktion Run(). Es wird der Name einer Funktion übergeben, die aufgerufen wird, um die Darstellung des Assistenten und die möglichen nächsten Dialogschritte festzulegen. Der zweite Parameter ist ein Wahrheitswert und legt fest, wie die Abarbeitung der Dialogschrittschritte gesteuert wird. Ist der Parameter true, übernimmt der Assistent einige Aufgaben selbst, wie zum Beispiel den Aufruf zur Anzeige des nächsten Dialogschritts (siehe Kapitel 7.5.1). Ist er false, übernimmt der ISOM/LProgrammierer diese Aufgaben; dies ermöglicht ihm eine größere Flexibilität, überträgt ihm aber auch mehr Verantwortung (siehe Kapitel 7.5.2). Durch diese Unterscheidung ergeben sich zwei Arten, auf die ein Assistent definiert werden kann. 7.5.1 Schrittsteuerung durch den Assistenten Die in Run() übergebene Funktion beschreibt, wie der erste Dialogschritt aussieht. Nach Auswertung der Funktion wird der Schritt automatisch angezeigt. Der durch die Schaltfläche „Weiter“ erreichbare nächste Dialogschritt wird mit der Funktion SetNext() angegeben. Als Parameter wird wiederum der Name der Funktion mit den Festlegungen des nächsten Dialogschritts übergeben. Eine Abfolge von Dialogen wird so durch die Verwendung von SetNext() in der beschreibenden Funktion jedes Einzelschritts definiert. Codeauszug 44 verdeutlicht das Konzept. 76 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 Boolean StartWizard() 02 { 03 // Assistenten erstellen 04 Wizard wizard = wizard.Create(); 05 06 // Titel des Reiters für Inhalte mit Benutzerinteraktionen wizard.SetContentTitle("Hinweise"); 07 /* Der Assistent beginnt mit dem Dialogschritt, 08 der durch die Funktion 'Step1' definiert wird. */ 09 wizard.Run("Step1", true); 10 } 11 12 Boolean Step1(Wizard wizard) 13 { 14 // ... 15 // Verknüpft die Weiter-Schaltfläche mit 'Step2' 16 SetNext("Step2", false); 17 // ... 18 } 19 20 Boolean Step2(Wizard wizard) 21 { 22 23 24 25 26 27 28 29 30 31 32 // ... // Verknüpft die Weiter-Schaltfläche mit 'Exit' SetNext("Exit", true); // ... } Boolean Exit(Wizard wizard) { // löscht den Assistenten wizard.Dispose(); } Codeauszug 44: Schrittsteuerung durch den Assistenten Mit SetUpdateFunction() lässt sich für die automatische Schrittverwaltung bei der Festlegung eines Dialogschritts auch eine Funktion angeben, die vor der Anzeige des Dialogschritts gestartet wird. Sie erlaubt es, durch Aufruf der Funktionen UpdateMessage() und UpdateMeasurement() die Anzeige zu aktualisieren. Bei der automatischen Schrittverwaltung baut die Definition eines Schritts auf einem leeren Schritt auf, sodass keine Elemente des vorhergehenden Dialogschritts übernommen werden. Eine Ausnahme bilden dabei die Festlegungen, die vor dem Aufruf von Run() getroffen wurden. Sie gelten für jeden Dialogschritt, ohne dass sie explizit angegeben werden müssen. 77 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Bei der automatischen Schrittverwaltung wird bei Betätigung der „Zurück“-Schaltfläche die Funktion des vorhergehenden Dialogschritts ausgeführt. Diese Funktionalität lässt sich mit DisableBack() deaktivieren. Codeauszug 45 zeigt die Verwendung von Assistenten zur Darstellung eines einfachen Taschenrechners. 78 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 /* * ISOM/L-Beispielprogramm: Wizard.is * Assistent (Taschenrechner) */ using Isom.Sys.*; using Isom.Base.*; using Isom.Request.*; namespace CalculatorWizard { /* Startet den Assistenten */ Boolean StartCalculatorWizard() { // Assistenten erzeugen und starten Wizard w = Wizard.Create(); w.SetTitle("Taschenrechner"); w.SetContentTitle("Inhaltstitel"); w.SetQuit("WizardExit"); w.Run("WizardInputNumbers", true); w.Dispose(); return true; } /* Schritt 1: Zeigt zwei Texteingabefelder an */ Boolean WizardInputNumbers(Wizard w) { 79 von 109 7 Bedienoberfläche und Benutzerinteraktion w.DisableBack(); w.SetContentTitle("Eingabe"); w.AddMessage("keyInputMsg", "Geben Sie zwei Zahlen ein:"); String initA = "0"; String initB = "0"; if(w.IsVisited()) { Number a = w.GetNumber("keyNumA"); initA = a.ToFloatString(); Number b = w.GetNumber("keyNumB"); initB = b.ToFloatString(); } w.AddTextInput("keyValA", "Erste Zahl:", initA); w.AddTextInput("keyValB", "Zweite Zahl:", initB); w.SetNext("WizardSelectOp", false); Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 return true; } /* Schritt 2: Auswahl einer Verknüpfung */ Boolean WizardSelectOp(Wizard w) { w.SetContentTitle("Auswahl"); String valA = w.GetTextInput("keyValA"); String valB = w.GetTextInput("keyValB"); Number a = valA.ParseNumber(); Number b = valB.ParseNumber(); w.AddNumber("keyNumA", a); w.AddNumber("keyNumB", b); String msg = "Es wurden die Zahlen '$a' und '$b' eingegeben. Wählen Sie eine Verknüpfung:"; msg.Replace("$a", a.ToFloatString()); msg.Replace("$b", b.ToFloatString()); w.AddMessage("keyOpMsg", msg); RadioButton rbAdd = w.AddRadioButton("rbAdd", "+ (Addition)"); rbAdd.SetWizardNext("WizardAdd"); RadioButton rbSub = w.AddRadioButton("rbSub", "- (Subtraktion)"); rbSub.SetWizardNext("WizardSub"); RadioButton rbMul = w.AddRadioButton("rbMul", "* (Multiplikation)"); rbMul.SetWizardNext("WizardMul"); RadioButton rbDiv = w.AddRadioButton("rbDiv", "/ (Division)"); rbDiv.SetWizardNext("WizardDiv"); rbAdd.Select(); return true; } /* Ergebnis: Addition */ Boolean WizardAdd(Wizard w) { 80 von 109 7 Bedienoberfläche und Benutzerinteraktion w.SetContentTitle("Ergebnis"); Number a = w.GetNumber("keyNumA"); Number b = w.GetNumber("keyNumB"); Number res = a.Clone(); res.Add(b); String msg = "$a + $b = $res"; Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 msg.Replace("$a", a.ToFloatString()); msg.Replace("$b", b.ToFloatString()); msg.Replace("$res", res.ToFloatString()); w.AddMessage("keyAddResMsg", msg); w.SetNext("WizardExit", true); return true; } /* Ergebnis: Subtraktion */ Boolean WizardSub(Wizard w) { w.SetContentTitle("Ergebnis"); Number a = w.GetNumber("keyNumA"); Number b = w.GetNumber("keyNumB"); Number res = a.Clone(); res.Sub(b); String msg = "$a - $b = $res"; msg.Replace("$a", a.ToFloatString()); msg.Replace("$b", b.ToFloatString()); msg.Replace("$res", res.ToFloatString()); w.AddMessage("keySubResMsg", msg); w.SetNext("WizardExit", true); return true; } /* Ergebnis: Multiplikation */ Boolean WizardMul(Wizard w) { 81 von 109 7 Bedienoberfläche und Benutzerinteraktion w.SetContentTitle("Ergebnis"); Number a = w.GetNumber("keyNumA"); Number b = w.GetNumber("keyNumB"); Number res = a.Clone(); res.Mul(b); String msg = "$a * $b = $res"; msg.Replace("$a", a.ToFloatString()); msg.Replace("$b", b.ToFloatString()); msg.Replace("$res", res.ToFloatString()); w.AddMessage("keyMulResMsg", msg); Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 } w.SetNext("WizardExit", true); return true; } /* Ergebnis: Division */ Boolean WizardDiv(Wizard w) { w.SetContentTitle("Ergebnis"); Number a = w.GetNumber("keyNumA"); Number b = w.GetNumber("keyNumB"); if(b.Eq(0)) { w.AddMessage("keyDivByZeroMsg", "Division durch 0!"); } else { Number res = a.Clone(); res.Div(b); String msg = "$a / $b = $res"; msg.Replace("$a", a.ToFloatString()); msg.Replace("$b", b.ToFloatString()); msg.Replace("$res", res.ToFloatString()); w.AddMessage("keyDivResMsg", msg); } w.SetNext("WizardExit", true); return true; } /* Beendet den Assistenten */ Boolean WizardExit(Wizard w) { w.Dispose(); return true; } Boolean main() { StartCalculatorWizard(); return true; } Codeauszug 45: Wizard.is 82 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Die durch Ausführung des Programms in Codeauszug 45 angezeigten Assistentenfenster sind in den nachfolgenden Abbildungen dargestellt. Der Benutzer kann über die Schaltfläche „Zurück“ zu vorhergehenden Schritten wechseln und die dort getätigten Eingaben und ausgewählten Optionen korrigieren. Die auf der rechten Seite sichtbaren Registerkarten „Beschreibung“ und „Media“ können Dokumente (z.B. PDF) und Mediendateien (z.B. Filme) aufnehmen. Abbildung 5: Taschenrechner – Eingabe der Operanden 83 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Abbildung 6: Taschenrechner – Auswahl des Operators Abbildung 7: Taschenrechner – Ergebnis 84 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 7.5.2 Manuelle Schrittsteuerung durch den Programmierer Die in Run() übergebene Funktion enthält in diesem Modus den gesamten Dialogablauf. Der Programmierer steuert in der Funktion selbst, wann ein Schritt angezeigt wird. Dazu stehen ihm die zwei Funktionen ShowWizard() und WaitWizard() zur Verfügung. Ein Aufruf von ShowWizard() aktualisiert die Anzeige des Assistenten und kehrt zurück, ohne auf die Betätigung einer Schaltfläche zu warten. WaitWizard() aktualisiert die Anzeige und wartet auf die Betätigung einer Schaltfläche. Als Rückgabeergebnis eines Aufrufs von WaitWizard() wird der Schlüssel der betätigten Schaltfläche geliefert. Mögliche Rückgabewerte sind Next, Back und Quit. 85 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 Boolean StartWizard() { Wizard wizard = wizard.Create(); /* Der Assistent ruft die Funktion 'Dispatcher' auf, die eine autorengesteuerte Dialogabfolge enthält. */ wizard.Run("Dispatcher", false); } Boolean Dispatcher(Wizard wizard) { wizard.AddMessage("FirstMessage", "Erster Schritt: Warte auf Betätigung einer Schaltfläche..."); String button = wizard.WaitWizard(); switch (button) { case "Next": // Benutzer hat auf 'Weiter' geklickt { // ... } case "Back": // Benutzer hat auf 'Zurück' geklickt { // ... } case "Quit": // Benutzer hat den Assistenten beendet { 27 28 29 30 31 32 33 34 } // ... } default: { // ... } } Codeauszug 46: Manuelle Schrittsteuerung durch Programmierer 86 von 109 7 Bedienoberfläche und Benutzerinteraktion Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 8 Werkzeuge 8.1 Verwendung des Interpreters Die ausführbare Datei des ISOM-Interpreters heißt IsomInstance.exe und befindet sich im Verzeichnis Taurus\ISOM\bin. Es ist möglich, mehrere Instanzen von ISOM zur gleichen Zeit zu starten. In diesem Fall muss jeder Instanz eine eindeutige Sitzungs-ID übergeben werden. Im Kommandozeilenmodus wird die main-Funktion des übergebenen ISOM/L-Programms ausgeführt. Wenn es keine main-Funktion in dem betreffenden Programm gibt, wird das Programm auf korrekte Syntax und Semantik geprüft. In diesem Fall wird jedoch nichts ausgeführt, sondern eine Warnung ausgegeben, dass das Programm keine main-Funktion enthält. Bei der Ausführung eines Programms wird die Syntax und Semantik aller Namensräume geprüft. Über den Kommandozeilenparameter CheckProgramsOnly kann ISOM auch angewiesen werden, nur alle Programme zu prüfen, ohne eines auszuführen. Die Semantikprüfung kann mittels des Parameters –SemanticCheck=False ausgeschaltet werden. Zur Konfiguration von ISOM können Parameter auf der Kommandozeile angegeben werden. Dabei werden Parameter erkannt, die mit einem einfachen oder doppelten Bindestrich („-“ oder „--“) beginnen. Jedem Parameter kann durch Zuweisung mit dem Gleichheitszeichen ein Wert übergeben werden. Dabei dürfen keine Leerzeichen zwischen dem Parameter, dem Gleichheitszeichen und dem Wert stehen. Der Wert kann in einfache oder doppelte Anführungszeichen eingeschlossen werden. Er muss in Anführungszeichen eingeschlossen werden, falls er Leerzeichen, den Bindestrich oder das Gleichheitszeichen selbst enthält. Werden einzelne Optionen nicht über die Kommandozeile konfiguriert, werden die Werte aus der Konfigurationsdatei IsomInstance.exe.config verwendet, die sich im Binärverzeichnis des Kommandozeileninterpreters in Taurus\ISOM\bin befindet. Optionen, die über die Kommandozeile angegeben werden, haben stets Vorrang vor den entsprechenden Standardeinstellungen aus der Konfigurationsdatei. 87 von 109 8 Werkzeuge Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Für den Kommandozeilenmodus sind folgende Kommandozeilenparameter relevant: Kommandozeilenparameter Bedeutung -Program Ausführung des übergebenen ISOM/L-Programms im Kommandozeilenmodus. (Die Angabe dieses Parameters ist notwendig, alle weiteren Parameter in dieser Tabelle sind optional.) -Help Anzeigen der Hilfe -IsomlCheckOnly Nur Syntax- und Semantikprüfung der Programme durchführen -Debug Ausführung des per -Program übergebenen Programms im Einzelschrittmodus -Warnings Ausgabe von Warnungen aktivieren -IsomSession Sitzungs-ID -MaxRecursion maximale Rekursionstiefe für ISOM/L-Programme; Voreinstellung: 100 (einhundert) -MaxRuntime maximale Anzahl zulässiger ISOM/L-Instruktionen; Voreinstellung: 1000000 (eine Million) -NoLog Ereignisaufzeichnung ausschalten -SemanticCheck gibt an, ob eine Semantikprüfung der ISOM/L-Programme ausgeführt werden soll: true oder false Tabelle 2: Kommandozeilenparameter für den Kommandozeilenmodus 8.1.1 Herstellen einer Testumgebung Das vorliegende Handbuch ist Teil eines Archivs, das eine vollständige ISOM-Laufzeitumgebung enthält. Das Archiv kann in ein beliebiges Verzeichnis extrahiert werden („copy deployment“). Die ausführbare Datei des ISOM-Interpreters befindet sich unter Taurus\ISOM\bin\IsomInstance.exe. Angenommen, das Beispiel „Hello, world“ wurde im Verzeichnis Taurus\ISOM\doc\samples abgelegt, kann der ISOM-Interpreters wie folgt ausgeführt werden: Quellcodeauszug 01 IsomInstance.exe –Program="..\doc\Samples\HelloWorld.is" Codeauszug 47: Aufruf des ISOM-Interpreters 88 von 109 8 Werkzeuge Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 8.2 Einzelschrittausführung im Kommandozeilenmodus Der ISOM-Einzelschrittmodus (idb) ist nach dem Vorbild des C-Debuggers (cdb) gestaltet. Um ein Programm im Einzelschrittmodus auszuführen, muss der Kommandozeilenparameter -Debug angegeben werden. Im Einzelschrittmodus selbst erscheint (idb) als Eingabeaufforderung, an der Einzelschrittmodusbefehle ausgeführt werden können. Codeauszug 48 zeigt den Aufruf des Einzelschrittmodus. Quellcodeauszug 01 02 03 04 05 06 07 08 09 10 11 12 13 14 D:\ISOM Didact\Taurus\ISOM\bin>IsomInstance.exe –Program=..\doc\samples\Factorial.is -Debug Session ID: 12345678-1234-1234-1234-123456789012 Starte Isom mit der Main-Funktion des ISOM/L-Programms: D:\ISOM Didact\Taurus\ISOM\doc\samples\Factorial.is Isom Debugger 9.0.0.0 Copyright 2007 IFS Informationstechnik GmbH Um die Hilfe aufzurufen, geben Sie bitte 'help' ein. Der Kontext ist IFS (Ausführung 2) Factorial.is Zeile 34 : { (idb) _ Codeauszug 48: Aufruf eines Programms im Einzelschrittmodus 89 von 109 8 Werkzeuge Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Folgende Befehle (und teilweise Kurzformen davon) stehen im Einzelschrittmodus zur Verfügung: Einzelschrittmodus-Befehl Bedeutung help Anzeigen der Hilfe Wenn ein Einzelschrittmodus-Befehl als Parameter angegeben wird, wird eine detaillierte Hilfe zu diesem Befehl angezeigt. break Haltepunkt setzen clear Haltepunkt löschen info Informationen zu gesetzten Haltepunkten continue, c Wiederaufnahme der angehaltenen Ausführung next, n Weiterführung der angehaltenen Ausführung um einen Schritt Funktionsaufrufe werden dabei zu einem Schritt zusammengefasst. step, s Weiterführung der angehaltenen Ausführung um einen Schritt Funktionsaufrufe werden dabei nicht zu einem Schritt zusammengefasst. finish, f Weiterführung der angehaltenen Ausführung bis zum Ende des aktuellen Funktionsaufrufs print, p Ausgabe eines Variablenwerts list Ausgabe einer Stelle im Quelltext set Konfigurationen setzen backtrace, bt Ausgabe der Namen aller Funktionen auf dem Aufrufstapel quit Einzelschrittmodus beenden Tabelle 3: Befehle im ISOM-Einzelschrittmodus 90 von 109 8 Werkzeuge Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 9 Syntaxgraphen von ISOM/L In diesem Kapitel wird die zulässige Syntax von ISOM/L-Programmen anhand von Syntaxgraphen dargestellt. Syntaxgraphen sind benannte, gerichtete Graphen, in denen runde Knoten Eingabesymbole darstellen und eckige Knoten auf andere Graphen verweisen. Ein Graph stellt dabei eine Phrase bzw. ein Element der Sprache dar. Kommentare werden nicht in die folgende Grammatikdefinition aufgenommen, da sie überall im Quelltext angegeben werden können. Abbildung 8: Grundelemente von Syntaxgraphen Die Grundelemente der Syntaxgraphen sind in Abbildung 8 in folgender Notation wiedergegeben: „Folgen“ beschreiben eine Sequenz von Phrasen, die genau in dieser Form in einem gültigen Satz der Sprache auftreten müssen. Eine „Auswahl“ stellt mögliche Phrasen dar, wobei genau eine dieser Phrasen an dieser Stelle des Satzes auftreten muss. 91 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 9.1 „Optionen“ sind Phrasen, die an dieser Stelle optional vorkommen können. „Repetitionen“ sind Phrasen, die an dieser Stelle beliebig oft, aber auch keinmal vorkommen können. Grundelemente der Syntax Abbildung 9 zeigt den Aufbau der Grundelemente der ISOM/L-Syntax. Grundelemente, die nicht weiter aufgeschlüsselte Wörter der Sprache darstellen, werden „Terminale“ genannt. Diese Elemente sind in Abbildungen jeweils durch Kreise oder Ovale gekennzeichnet. Nicht-Terminale sind durch Rechtecke dargestellt und werden durch die Regel gebildet, deren Name in dem Rechteck steht. Abbildung 9: Grundelemente der Syntax von ISOM/L Digit steht für ein Element der arabischen Zahlensymbole. Für HexDigit wird diese Menge um die lateinischen Buchstaben „a“ bis „f“ in kleiner und großer Schreibweise erweitert. 92 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Allgemeine Zeichenketten werden durch den Graphen String repräsentiert, dürfen aber keine Textbegrenzungszeichen („"“) oder \u0080-Zeichen enthalten. Das erste Zeichen wird für Zeichenkettenkonstanten verwendet. Das zweite Zeichen wird intern verwendet, um ein Dateiende anzuzeigen. Ein Beispiel für eine zulässige Zeichenkette ist Test. 9.2 Syntax der Konstanten und Bezeichner Mithilfe der Syntax-Grundelemente können Zahlenkonstanten gebildet werden. Abbildung 10 zeigt diese Sprachelemente. Der Graph UnsignedInteger bildet natürliche Zahlen (d.h. einschließlich der Null) ab, die aus mindestens einer Ziffer bestehen. SignedInteger erweitert natürliche Zahlen zu ganzen Zahlen. Er wird in der Definition für Zahlen in dezimaler Form im Graphen DecNumber verwendet. Diese Zahlen besitzen optional ein negatives Vorzeichen zur Darstellung negativer Zahlen und mindestens eine Dezimalzahl. Durch „.“ eingeleitet lassen sich Nachkommastellen angeben. Ein Punkt ohne Angabe einer Nachkommastelle ist dabei zulässig. Optional lässt sich eine Dezimalzahl durch einen Exponenten erweitern, indem dieser entweder durch „e“ oder „E“ angezeigt wird, gefolgt von einer ganzen Zahl. Beispiele für gültige Angaben von Dezimalzahlen sind „3.14“, „0.“ und „2.0E-3“. Der Graph HexNumber beschreibt Zahlen in hexadezimaler Schreibweise. Diesen steht immer „0x“ oder „0X“ voran. Beispiele für gültige Angaben von Hexadezimalzahlen sind „0xFF“ und „0X2143“. 93 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Abbildung 10: Darstellung von numerischen Literalen in ISOM/L Konstanten und Bezeichner werden aus Grundelementen geformt. Abbildung 11 zeigt die Konstruktion von Bezeichnern. ShortIdentifier müssen innerhalb von ISOM/L mit einem Buchstaben beginnen und dürfen danach nur Buchstaben, Ziffern oder den Unterstrich „_“ enthalten. Beispiele für gültige Angaben von Kurznamen sind „x“ und „Boolean“. Ein SubsequentShortIdentifier ist eine beliebige Folge von Buchstaben, Ziffern und Unterstrichen. Kurze Bezeichner ShortIdentifier und SubsequentShortIdentifier können mit „.“ zu Identifier verkettet werden. Zum Beispiel ist Isom.Base.Boolean ein gültiger Identifier. Abbildung 12 zeigt die Konstruktion von Zeichenkettenliteralen und von Konstanten. StringLiteral zeigt die Definition der Zeichenketten in ISOM/L, die durch „\“ beliebig oft verkettet werden können. Dies bietet eine gute Überschaubarkeit der in ISOM/L verwendeten Zeichenketten, die auf diese Weise übersichtlich in aufeinander folgenden Zeilen definiert werden können. Der Graph Constant zeigt die Werte-Konstanten in ISOM/L. Sie können wie durch die Graphen DecNumber, HexNumber oder StringLiteral vorgegeben konstruiert werden oder sind durch die Schlüsselwerte true und false repräsentiert. 94 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Abbildung 11: Bezeichner in ISOM/L Abbildung 12: Konstanten und Zeichenkettenliterale Die Bezeichner und Konstanten bilden zusammen mit den Schlüsselwörtern und Sonderzeichen (z.B. Klammern) den Wortschatz von ISOM/L. Mithilfe dieses Wortschatzes kann der Aufbau 95 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München von ISOM/L-Programmen anhand der Syntaxgraphen definiert werden. 9.3 Syntaktischer Aufbau einer ISOM/L-Datei Die Definition einer ISOM/L-Datei ist in Abbildung 13 als Graph mit dem Namen IsomProgram dargestellt. ISOM/L-Dateien beginnen mit einer Sequenz von using-Anweisungen, dem UsingImport und Deklarationen anonymer Namensräume als AnonymousNamespace. Optional folgt danach eine Namensraumdeklaration Namespace, die einen nicht anonymen Namensraum beschreibt. Die Graphen dieser Sprachelemente sind in Abbildung 13 dargestellt. 96 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Abbildung 13: Grammatikaufbau auf der obersten Ebene in ISOM/L 97 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Mithilfe von using und einem Bezeichner lassen sich Textdefinitionen und Funktionen anderer Dateien importieren. Optional lässt sich durch „.*“ angeben, dass alle Namensräume einbezogen werden, die eine Ebene unterhalb des angegeben Namensraums liegen. Zum Beispiel ist using Isom.Base.* ein syntaktisch gültiger UsingImport. Ein nicht anonymer Namensraum Namespace besteht aus Annotationen, einem Namen, der ihn identifiziert, sowie aus Funktionsdeklarationen und Textdefinitionen, die innerhalb der geschweiften Klammern in beliebiger Reihenfolge stehen können. Ein Beispiel für einen syntaktisch gültigen Namensraum ist namespace Isom.Empty{ }. Zur Angabe eines Namensraums bzw. ISOM/L-Typs werden zusammengesetzte Bezeichner Identifier benutzt. Es wird zusätzlich festgelegt, dass die zwei letzten verketteten ShortIdentifier oder SubsequentShortIdentifier in diesem Identifier unterschiedlich sind. Ein Namensraum wie zum Beispiel Isom.Global.Global wird somit ausgeschlossen. Diese Einschränkung hat ihren Grund in der benötigten Zuordenbarkeit des Ablagepfads der Programme im Dateisystem. Das Konzept der Dateiablage wird in Kapitel 5.1 erläutert. Anonyme Namensräume zeichnen sich dadurch aus, dass sie keinen Namensraumbezeichner enthalten. Eine Sequenz anonymer Namensräume kann einem nicht anonymen Namensraum vorangestellt werden. Annotationen, Funktionen und Textinhalte solcher Namensräume werden beim Einlesen des Programms automatisch als Teil des nicht anonymen Namensraums übernommen. Der Graph Extension zeigt die Erweiterung einer Klasse des ISOM-Objektmodells. Sie wird mithilfe des Schlüsselworts extension definiert. Eingeleitet durch deftext wird eine TextDefinition angegeben, deren Texte einer externen Textverwaltung zur Verfügung gestellt werden können. Eine Textdefinition enthält danach eine Angabe zur Textkategorie, zum Beispiel ButtonText als Text für eine Schaltfläche. Darauf folgen der Name, der den Text innerhalb des Namensraums identifiziert, und ein Standard-Ausgabetext. Dies ermöglicht die Übersetzung der Texte, die in den Programmen enthalten sind, in verschiedene Sprachen. Gleichzeitig können diese Texte durch ihren eindeutigen Namen zugeordnet und als Zeichenketten typisiert werden. Ein Beispiel für die gültige Syntax einer Textdefinition ist deftext ButtonText BTN_OK “Ok“. 98 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 9.4 Syntax einer ISOM/L-Funktionsdeklaration Abbildung 14: Funktionsdeklarationen in ISOM/L Der notwendige Teil einer Funktionsdeklaration beginnt mit einem Typnamen in Form eines zusammengesetzten Bezeichners oder eines Typ-Kurznamens. Es folgt ein Funktionsname, der ein einfacher Bezeichner ist. Zwischen runden Klammern werden die Parameter der Funktion definiert, danach folgt ein SimpleStatement, das den Funktionsrumpf enthält. SimpleStatement wird in Kapitel 9.5 erläutert. Die Syntax der Parameterangaben wird durch den Graphen ParameterDeclarations abgebildet. Sie besteht aus einer Liste von einzelnen Parameterdeklarationen, die durch Kommata getrennt sind. Die Liste darf leer sein. Eine einzelne Parameterdeklaration enthält die Angabe eines Typnamens und eines Parameternamens, die nach den Graphen für Identifier und ShortIdentifier gebildet werden. Zum Beispiel ist Number Add(Number other); eine zulässige Funktionsdeklaration. 99 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 9.5 Syntax der ISOM/L-Anweisungen Abbildung 15 und Abbildung 16 zeigen alle Anweisungen, die von ISOM/L erkannt werden. SimpleStatement stellt eine Anweisung dar, die, falls sie eine Blockanweisung ist, keinen abschließenden Block enthalten kann. Statement stellt eine Anweisung dar, die einen abschließenden Block enthalten kann, auch wenn sie eine Blockanweisung ist. Beide unterscheiden sich nur darin, ob als Blockanweisung SimpleBlockStatement oder BlockStatement zugelassen ist. SimpleBlockStatement ist eine Blockanweisung, auf die kein abschließender Block folgen darf. Auf BlockStatement darf dagegen ein abschließender Block folgen. Dabei sind die komplexeren Anweisungstypen in den Syntaxgraphen von Abbildung 15 und Abbildung 16 einzeln als Syntaxgraphen dargestellt. Abbildung 15: Definition von Anweisungen in ISOM/L (1) 100 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Abbildung 16: Definition von Anweisungen in ISOM/L (2) Die einfachen Anweisungen umfassen break-, continue und leave sowie die Funktionsrückgabe durch return. Ausdrücke gefolgt von einem Semikolon können als Anweisungen verwendet werden, wie zum Beispiel der Aufruf einer Funktion, der als Ausdruck durch den Graphen Expression in Abbildung 19 definiert ist. Es gibt eine Zuweisungsanweisung und weitere komplexere Anweisungen wie die Blockschachtelung von Anweisungen, die Programmverzweigungen durch die if- und switch-Anweisung und die Programmschleife, eingeleitet durch das Schlüsselwort while. 101 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Abbildung 17: Definition von komplexen Anweisungen in ISOM/L (1) 102 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Abbildung 18: Definition von komplexen Anweisungen in ISOM/L (2) Eine Variablendeklaration besteht syntaktisch aus einem zusammengesetzten Bezeichner, der die Typangabe der Variablen ist, und einem einfachen Bezeichner, der der Name der Variablen ist, gefolgt von einem Semikolon „;“. Optional lässt sich ein Ausdruck, der der Variable zugewiesen ist, mittels „=“ angeben. Zum Beispiel ist Number n = f(); eine Variablendeklaration. Durch geschweifte Klammern lässt sich eine Blockanweisung angeben, die beliebig viele Anweisungen enthalten kann. ISOM/L verwendet für Programmverzweigungen die zwei Formen if und switch. Die Sprache besitzt ein Schleifenkonstrukt, das durch while eingeleitet wird, wie in Abbildung 17 veranschaulicht. Bei der while-Schleife ist zu beachten, dass der abschließende Block nicht bei jedem Schleifendurchlauf, sondern nach dem Verlassen der Schleife genau einmal ausgeführt wird. Daher wurde in der Darstellung SimpleBlockStatement und Finalizer nicht zu BlockStatement zusammengefasst. 103 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München 9.6 Syntax der ISOM/L-Ausdrücke Abbildung 19 enthält alle gültigen Ausdrücke, die in Ausdrucksanweisungen als rechte Seite von Zuweisungen, als Bedingungen oder als Teil der return-Anweisung verwendet werden können. Dies sind Konstanten, einfache Bezeichner, die für Variablen oder durch deftext eingeführte Textbezeichner stehen, das Schlüsselwort this oder Funktionsaufrufe. In Funktionsaufrufen kann das Schlüsselwort base verwendet werden, um bei überschriebenen Fachfunktionen die Basisimplementierung auszuführen. Die Syntax erlaubt Funktionsaufrufen die Angabe von übergebenen Parametern, die ihrerseits als Ausdrücke definiert sind. Mehrere Übergabeparameter werden durch Kommata getrennt. Zum Beispiel ist f(x, g(), true) ein Funktionsaufruf. Er enthält einen zweiten Funktionsaufruf als Parameter. Abbildung 19: Definition von Ausdrücken in ISOM/L 104 von 109 9 Syntaxgraphen von ISOM/L Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Verzeichnisse und Anhänge A Verzeichnis der Tabellen Tabelle 1: Arten von Bedienelementen ............................. 71 Tabelle 2: Kommandozeilenparameter für den Kommandozeilenmodus ... 88 Tabelle 3: Befehle im ISOM-Einzelschrittmodus .................... 90 B Verzeichnis der Abbildungen Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung Abbildung C 1: Ausführung des Programms „Hello, world“ ............. 10 2: Finden von Programmen ............................... 57 3: Leeres Dialogfenster ................................ 70 4: Dialogfenster mit Bedienelementen ................... 73 5: Taschenrechner – Eingabe der Operanden .............. 83 6: Taschenrechner – Auswahl des Operators .............. 84 7: Taschenrechner – Ergebnis ........................... 84 8: Grundelemente von Syntaxgraphen ..................... 91 9: Grundelemente der Syntax von ISOM/L ................. 92 10: Darstellung von numerischen Literalen in ISOM/L .... 94 11: Bezeichner in ISOM/L ............................... 95 12: Konstanten und Zeichenkettenliterale ............... 95 13: Grammatikaufbau auf der obersten Ebene in ISOM/L ... 97 14: Funktionsdeklarationen in ISOM/L ................... 99 15: Definition von Anweisungen in ISOM/L (1) .......... 100 16: Definition von Anweisungen in ISOM/L (2) .......... 101 17: Definition von komplexen Anweisungen in ISOM/L (1) 102 18: Definition von komplexen Anweisungen in ISOM/L (2) 103 19: Definition von Ausdrücken in ISOM/L ............... 104 Verzeichnis der Codeauszüge Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug 105 von 109 Verzeichnisse und Anhänge 1: 2: 3: 4: 5: 6: 7: 8: 9: HelloWorld.is ....................................... 9 Kommentare ......................................... 12 HelloWorldWithComments.is .......................... 14 HelloWorldWithUsing.is ............................. 15 HelloWorldWithUsing2.is ............................ 16 HelloWorldWithDeftext.is ........................... 17 IfElseStdio.is ..................................... 20 IfElseEnv.is ....................................... 22 Bedingte Codeausführung mit switch/case/default .... 23 Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug Codeauszug 106 von 109 Verzeichnisse und Anhänge 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46: 47: 48: Factorial.is ...................................... FinallyBlock.is ................................... FinallyBlockAndLeave.is ........................... FinallyBlockAfterIfElse.is ........................ FinallyBlockAfterSwitch.is ........................ FinallyBlockAfterWhile.is ......................... Variablendefinition und Zuweisung ................. Beispiele für Literale ............................ Beispiele für Fachfunktionen der Basisobjekte ..... ParameterPassing.is ............................... Unzulässige Zuweisung an Parametervariablen ....... Beispiel für einen Namensraum mit Funktionen ...... Fachfunktionen Objekterzeugung/-bereitstellung .... Ungültig-Machen von Objektinstanzen mit Void() .... Fehlerhafte Verwendung von Void() ................. Fehlerbehandlung mit Boolean.Failed ............... CheckVoid.is und Ausgabe .......................... ExNumberList.is ................................... ExStringDictionary.is ............................. Erweiterung von Isom.Base.String .................. Fibonacci.is ...................................... Beispiele für gültige Namensraumbezeichner ........ Beispiele für Importanweisungen ................... Beispiel für Datei TextCategoryData.xml ........... Beispiele für Textdefinitionen .................... Einbinden ausgelagerter Quelltextteile ............ Stdio.is .......................................... OutputText.is ..................................... WriteXml.is ....................................... Ergebnis der Ausführung von Codeauszug 38 ......... LoadXml.is ........................................ ExUserRequest.is .................................. ExUserRequest2.is, CreateNewRequest() ............. ExUserRequest3.is, erw. main()-Funktion ........... Schrittsteuerung durch den Assistenten ............ Wizard.is ......................................... Manuelle Schrittsteuerung durch Programmierer ..... Aufruf des ISOM-Interpreters ...................... Aufruf eines Programms im Einzelschrittmodus ...... Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 24 26 27 28 29 30 32 33 34 37 38 39 40 42 42 43 45 47 49 53 55 56 58 59 60 60 62 64 65 65 66 70 72 76 77 82 86 88 89 Excellence in Automotive Computing. Informationstechnik München D E Referenzen Referenz auf [1] IFS Informationstechnik München: ISOM Didact, http://www.ifsit.de/index.php?id=13, abgerufen am 22.02.2012. [2] IFS Informationstechnik München: BZ-8361 ISOM/L-Bibliothek für Serviceautoren, http://www.ifs-it.de/index.php?id=13, abgerufen am: 22.02.2012. [3] IFS Informationstechnik München: BZ-12907 Glossar der Serviceplattform Taurus®, http://www.ifs-it.de/index.php?id=taurus, abgerufen am: 22.02.2012. Anhang: Überblick über die Schlüsselwörter in ISOM/L In der nachfolgenden Tabelle sind einundzwanzig Schlüsselwörter, die ISOM/L verwendet, sowie Präprozessoranweisungen im Überblick aufgelistet. Schlüsselwörter können nicht als Bezeichner, zum Beispiel als Variablennamen, verwendet werden. Schlüsselwörter sind wie Bezeichner bezüglich ihrer Groß- und Kleinschreibung eindeutig festgelegt. Schlüsselwort Verwendung base Aufruf der Basisimplementierung einer Fachfunktion, die in einer extension-Deklaration überschrieben wurde break Abbruch-Anweisung case Angabe eines Falls in einer switch-Konstruktion continue Anweisung zur erneuten Auswertung einer Schleifenbedingung default Angabe des Standardfalls in einer switch-Konstruktion deftext Textdefinition else optionaler, zweiter Fall einer if-Anweisung extension Erweiterung einer Klasse des ISOM-Objektmodells false Konstante des Wahrheitswerts „falsch“ finally abschließender Block if Einleitung einer Fallunterscheidung mit zwei Fällen 107 von 109 Verzeichnisse und Anhänge Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Schlüsselwort Verwendung #include .isi-Datei einfügen leave Anweisung zum Sprung in einen abschließenden Block namespace Namensraumdeklaration objectbound Kennzeichnung einer instanzgebundenen Fachfunktion return Funktionsrückgabe switch Fallunterscheidung mit beliebig vielen Fällen und einem Standardfall this Verwendung der Objektinstanz in einer extensionDeklaration true Konstante des Wahrheitswerts „wahr“ using Namensraumeinbindung while Schleifenkonstruktion 108 von 109 Verzeichnisse und Anhänge Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013 Excellence in Automotive Computing. Informationstechnik München Vorgang: BZ-9758 Kurztitel: Einführung ISOM/L Version: 3.1, 18. Juni 2013