Bartels User Language
Programmierhandbuch

PDF-Version (2,3 MB; aktualisiert 11. November 2013)

Inhalt

Gliederung

Weitere Dokumentation

Wünsche, Anregungen, Fragen, Probleme

Begriffe

Konventionen

Copyright

1.1

Was ist Bartels User Language?

1.1.1

Verwendungszweck

1.1.2

Bestandteile

1.2

Charakteristische Eigenschaften der User Language

1.2.1

Bartels User Language im Vergleich zu C

1.2.2

Datentypen, Konstanten, Variablen

1.2.3

Operatoren, Zuweisungen

1.2.4

Kontrollstrukturen

1.2.5

Programmfluss, Funktionen

1.2.6

Integrierte Spezialfunktionen

2.1

Einführung in die User Language Programmierung

2.1.1

Ein erstes User Language Programm

2.1.2

Variablen, Arithmetik und Funktionen

2.1.3

Vektoren und Kontrollstrukturen

2.2

Konventionen

2.2.1

Zwischenraum

2.2.2

Identifier

2.2.3

Konstanten und konstante Ausdrücke

2.2.4

Terminalzeichen-Sequenzen

2.3

Datentypen und Definitionen

2.3.1

Datentypen

2.3.2

Variablen

2.3.3

Funktionen

2.3.4

Regeln zum Geltungsbereich

2.4

Ausdrücke

2.4.1

Primäre Ausdrücke

2.4.2

Unitäre Ausdrücke

2.4.3

Binäre Ausdrücke

2.4.4

Liste von Ausdrücken

2.4.5

Vorrang und Reihenfolge der Bewertung

2.5

Kontrollstrukturen

2.5.1

Sequentielle Programm-Elemente

2.5.2

Alternativen

2.5.3

Repetitionen

2.5.4

Kontrollfluss-Steuerung

2.6

Preprozessor-Anweisungen

2.6.1

Dateieinbindung

2.6.2

Konstantendefinition

2.6.3

Bedingte Übersetzung

2.6.4

BNF-Precompiler

2.6.5

Programmaufruftyp und Undo-Mechanismus

2.7

Syntaxdefinition

3.1

Konventionen

3.1.1

Programmspeicherung

3.1.2

Maschinenarchitektur

3.2

Compiler

3.2.1

Arbeitsweise

3.2.2

Compileraufruf

3.2.3

Fehlerbehandlung

3.3

Interpreter

3.3.1

Arbeitsweise

3.3.2

Programmaufruf

3.3.3

Fehlerbehandlung

4.1

User Language-Includedateien

4.1.1

Standard-Includedateien

4.1.2

SCM-Includedateien

4.1.3

Layout-Includedateien

4.1.4

IC-Design-Includedateien

4.2

User Language-Programme

4.2.1

Standard-Programme

4.2.2

SCM-Programme

4.2.3

Layout-Programme

4.2.4

GED-Programme

4.2.5

Autorouter-Programme

4.2.6

CAM-Prozessor-Programme

4.2.7

CAM-View-Programme

4.2.8

IC-Design-Programme

4.2.9

CED-Programme

4.3

Bereitstellung der User Language-Programme

4.3.1

Kompilierung

4.3.2

Menübelegung und Tastaturprogrammierung

A.1

Konventionen

A.1.1

Interpreterumgebung

A.1.2

Aufruftyp

A.2

Wertebereichsdefinitionen

A.2.1

Standard Wertebereiche (STD)

A.2.2

Schematic Capture Wertebereiche (CAP)

A.2.3

Schematic Editor Wertebereiche (SCM)

A.2.4

Layout Wertebereiche (LAY)

A.2.5

CAM-Prozessor Wertebereiche (CAM)

A.2.6

IC Design Wertebereiche (ICD)

B.1

Index-Übersicht

B.1.1

Standard Index-Variablen-Typen (STD)

B.1.2

Schematic Capture Index-Variablen-Typen (CAP)

B.1.3

Layout Index-Variablen-Typen (LAY)

B.1.4

CAM-View Index-Variablen-Typen (CV)

B.1.5

IC Design Index-Variablen-Typen (ICD)

B.2

Standard Index-Beschreibung (STD)

B.3

Schematic Capture Index-Beschreibung (CAP)

B.4

Layout Index-Beschreibung (LAY)

B.5

CAM-View Index-Beschreibung (CV)

B.6

IC Design Index-Beschreibung (ICD)

C.1

Funktionsübersicht

C.1.1

Standard Systemfunktionen (STD)

C.1.2

Schematic Capture Systemfunktionen (CAP)

C.1.3

Schematic Editor Systemfunktionen (SCM)

C.1.4

Layout Systemfunktionen (LAY)

C.1.5

Layouteditor Systemfunktionen (GED)

C.1.6

Autorouter Systemfunktionen (AR)

C.1.7

CAM-Prozessor Systemfunktionen (CAM)

C.1.8

CAM-View Systemfunktionen (CV)

C.1.9

IC Design Systemfunktionen (ICD)

C.1.10

Chip Editor Systemfunktionen (CED)

C.2

Standard-Systemfunktionen

C.3

SCM-Systemfunktionen

C.3.1

Schaltplan-Datenzugriffsfunktionen

C.3.2

Schaltplaneditor-Funktionen

C.4

PCB-Design-Systemfunktionen

C.4.1

Layout-Datenzugriffsfunktionen

C.4.2

Layouteditor-Funktionen

C.4.3

Autorouter-Funktionen

C.4.4

CAM-Prozessor-Funktionen

C.4.5

CAM-View-Funktionen

C.5

IC-Design-Systemfunktionen

C.5.1

IC-Design-Datenzugriffsfunktionen

C.5.2

Chipeditor-Funktionen

2-1

Darstellung von Sonderzeichen

2-2

Reservierte Worte

2-3

Operatoren

2-4

Operator Vorrang und Assoziativität

3-1

User Language Maschinen-Befehlssatz

3-2

Tastaturgesteuerter Programmaufruf

3-3

Ereignisgesteuerter Programmaufruf

A-1

User Language Aufruftypen

A-2

Kompatibilität Aufruftyp zu Aufruftyp

A-3

Kompatibilität Aufruftyp zu Interpreter

Vorwort

Das Bartels User Language - Programmierhandbuch enthält die Beschreibung der Bartels User Language-Programmiersprache sowie ausführliche Informationen über die Art der Einbindung sowie die Möglichkeiten der Anwendung im Bartels AutoEngineer-EDA-System. Im Bartels User Language - Programmierhandbuch finden Sie detaillierte Informationen zu den folgenden Themenschwerpunkten:

• Grundkonzept und Sprachbeschreibung der Bartels User Language
• Das Bartels User Language-Programmiersystem:
  User Language Compiler und User Language Interpreter
• User Language-Beispielprogramme; Informationen zu den mit dem Bartels AutoEngineer ausgelieferten User Language-Programmen
• Beschreibung der Datentypen für den Zugriff auf die Designdaten im Bartels AutoEngineer
• Beschreibung der in der Bartels User Language implementierten Systemfunktionen

Der Leser sollte vertraut sein mit der Benutzung seines Betriebssystems und mit der Handhabung eines auf seinem System verfügbaren Editors zur Erstellung von ASCII-Dateien. Darüber hinaus sollte der Anwender über hinreichende Erfahrungen in der Benutzung des Bartels AutoEngineer verfügen. Schließlich werden Kenntnisse der Programmierung im Allgemeinen sowie der Programmiersprache C im Speziellen vorausgesetzt.

AutoEngineer-Anwender, die keine eigene User Language-Programmierung planen, sollten zumindest einen Blick auf Kapitel 4 werfen, da darin Kurzbeschreibungen der mit der BAE-Software ausgelieferten User Language-Programme aufgelistet sind.

Beachten Sie bitte vor Verwendung der in dieser Dokumentation enthaltenen Informationen und der darin beschrieben Produkte die Copyright-Hinweise. Der Leser sollte darüber hinaus auch mit den in dieser Dokumentation verwendeten Begriffen und Konventionen vertraut sein.

Gliederung

Weitere Dokumentation

Die Bartels AutoEngineer® - Installationsanleitung beschreibt die Konfigurationen und Systemvoraussetzungen des Bartels AutoEngineer und enthält detaillierte Anweisungen zur Installation des Bartels AutoEngineer auf unterschiedlichen Hardware- und Softwareplattformen.

Das Bartels AutoEngineer® - Benutzerhandbuch enthält die Bedienungsanleitung für das Bartels AutoEngineer-CAE/CAD/CAM-System. Im Bartels AutoEngineer® - Benutzerhandbuch finden Sie detaillierte Informationen zu den folgenden Themenschwerpunkten:

• Einleitung: Systemarchitektur, allgemeine Bedienungshinweise, Designdatenbank
• Schaltungsentwurf (CAE), Schaltplaneditor
• Netzlistenverarbeitung, Forward- und Backward-Annotation
• Leiterplattenentwurf (CAD) und Fertigungsdatenerzeugung (CAM), Layouteditor für grafisch-interaktives Leiterkartenlayout, Autoplacement, Flächenautomatik, Autorouting, CAM-Prozessor, CAM-View
• IC-/ASIC-Design, Chipeditor für grafisch-interaktives IC-Maskenlayout, Cellplacer und Cellrouter für "Place & Route", Import- und Export von GDS- und CIF-Daten
• Neuronales Regelsystem
• Utilityprogramme

Die Bartels AutoEngineer® - Symbol- und Bauteilbibliotheken Dokumentation enthält detaillierte Informationen zu den mit dem Bartels AutoEngineer-CAE/CAD/CAM-System ausgelieferten Symbol- und Bauteilbibliotheken.

Wünsche, Anregungen, Fragen, Probleme

Für Hinweise auf Fehler sowie Wünsche und Anregungen in Bezug auf die Implementierung neuer oder die Weiterentwicklung bestehender Funktionen bzw. Programmteile des Bartels AutoEngineer bzw. der Bartels User Language sind wir Ihnen dankbar. Sollten Sie Fragen zur Bartels User Language haben, oder Probleme bei deren Benutzung auftreten, so wenden Sie sich bitte an unsere Support-Abteilung. Unsere Anschrift können Sie der Bartels Website unter http://www.bartels.de entnehmen.

Begriffe

Der Leser sollte vertraut sein mit den folgenden in der Bartels AutoEngineer-Dokumentation immer wiederkehrenden Begriffen:

In der Bartels AutoEngineer-Dokumentation werden die folgenden Akronyme verwendet:

Konventionen

Soweit nicht anders vermerkt sind in der Bartels AutoEngineer-Dokumentation folgende symbolische Konventionen relevant:

Lineprint	Schreibmaschinenzeichensatz kennzeichnet durch das System ausgegebenen Text.
Boldface	Fett gedruckte Worte oder Zeichen in Format- oder Kommandobeschreibungen kennzeichnen feststehende Begriffe oder syntaktische Terminalzeichensequenzen, also direkt einzusetzende Kommando- oder Schlüsselwörter.
Emphasize	Emphatische Textauszeichnung dient der optischen Hervorhebung.
" "	Anführungszeichen dienen der Kennzeichnung von (Pfad-)Namen oder spezifizieren direkt einzugebende Zeichen(sequenzen).
[ ]	Eckige Klammern in Format- oder Kommandobeschreibungen umschließen wahlweise angebbare Elemente.
{ }	Geschweifte Klammern in Format- oder Kommandobeschreibungen umschließen eine Liste von Elementen, aus denen eines anzugeben ist.
|	Ein vertikaler Strich trennt Elemente aus einer Liste wahlweise angebbarer Elemente.
< >	Gewinkelte Klammern umschließen den logischen Namen einer (zu betätigenden) Taste oder eine semantisch zu ersetzende syntaktische Variable in einer Format- oder Kommandobeschreibung.
>	Fett gedruckte Größerzeichen innerhalb Schreibmaschinenzeichensatz kennzeichnen Eingabeaufforderungen auf Betriebssystemebene.
...	Horizontale Auslassungspunkte kennzeichnen die wahlweise Wiederholbarkeit des vorhergehenden Elements in einer Format- oder Kommandobeschreibung oder die Auslassung irrelevanter Teile eines Beispieles oder einer Abbildung.
:	Vertikale Auslassungspunkte kennzeichnen die Auslassung irrelevanter Teile einer Abbildung, eines Beispieles, oder einer Format- oder Kommandobeschreibung.
	beliebige Maustaste (MB)
	Linke Maustaste (LMB)
	Mittlere Maustaste (MMB)
	Rechte Maustaste (RMB)
	Tastatur(eingabe) - Return-/Eingabetaste (CR)
a b ...	Tastatur(eingabe) - Standardtaste(n)
F1 F2 ...	Tastatur(eingabe) - Funktionstaste(n)
filename	Datei- bzw. Verzeichnispfadname.
keyword	Syntaktische Terminalzeichensequenz, also direkt einzusetzendes Kommando bzw. Schlüsselwort.
message	Von BAE oder System angezeigte Status- oder Fehlermeldung.
Menu	Bartels AutoEngineer Menü.
Menu Function	Bartels AutoEngineer Menüfunktion.
Menu Option	Bartels AutoEngineer Menüoption.
Button	Bartels AutoEngineer (Popup-)Menübutton.
ul.ulc	(Hypertextlink zu) Bartels User Language-Programmquellcodedatei.
ul.ulh	(Hypertextlink zu) Bartels User Language-Includedatei.
ulprog	(Hypertextlink zu) Bartels User Language-Programmbeschreibung.
ul_function	(Hypertextlink zu) Bartels User Language-Systemfunktionsbeschreibung.
UL_INDEX	(Hypertextlink zu) Bartels User Language-Indextypbeschreibung.
utilprog	(Hypertextlink zu) Bartels AutoEngineer Utilityprogrammbeschreibung.
neue Funktion	Neue Funktionen die mit regulären wöchentlichen Updates/Builds verfügbar gemacht werden, werden in der Onlinedokumentation hervorgehoben.

In Beispielen für höhere Programmiersprachen und Interpretationssprachen, in Objektbeschreibungen mittels Spezifikationssprachen, bei der Verwendung in Syntaxbeschreibungssprachen, etc. erhalten obige Sonderzeichensequenzen wieder die in der entsprechenden Sprache festgelegte Bedeutung.

Copyright

Die in der Dokumentation zum Bartels AutoEngineer enthaltenen Informationen werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt.

Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Herausgeber und Autoren können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Die Bartels System GmbH behält sich vor, die Dokumentation des Bartels AutoEngineer und die Spezifikation der darin beschriebenen Produkte jederzeit zu ändern, ohne diese Änderungen in irgend einer Form oder irgend welchen Personen bekannt geben zu müssen. Für Verbesserungsvorschläge und Hinweise auf Fehler ist der Herausgeber dankbar.

Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien. Die gewerbliche Nutzung der in diesen Dokumentationen gezeigten Modelle und Arbeiten ist nicht zulässig.

Bartels AutoEngineer®, Bartels Router® und Bartels Autorouter® sind eingetragene Warenzeichen der Bartels System GmbH. Bartels User Language™ und Bartels Neural Router™ sind Warenzeichen der Bartels System GmbH. Alle anderen verwendeten Produktbezeichnungen und Markennamen der jeweiligen Firmen unterliegen im Allgemeinen ebenfalls warenzeichen-, marken- oder patentrechtlichem Schutz.

1 Einleitung

Inhalt

1.1.1

Verwendungszweck

1.1.2

Bestandteile

1.2.1

Bartels User Language im Vergleich zu C

1.2.2

Datentypen, Konstanten, Variablen

1.2.3

Operatoren, Zuweisungen

1.2.4

Kontrollstrukturen

1.2.5

Programmfluss, Funktionen

1.2.6

Integrierte Spezialfunktionen

1.1 Was ist Bartels User Language?

1.1.1 Verwendungszweck

Durch den Einsatz der Bartels User Language ergeben sich praktisch unbegrenzte Möglichkeiten für den Zugriff auf die Datenbankinhalte sowie die Nutzung von Funktionen des Bartels AutoEngineer. Mit Hilfe der Bartels User Language lassen sich im Bartels AutoEngineer unter anderem

• CAM-Postprozessoren zur Ausgabe beliebiger Daten(formate) erzeugen
• anwenderspezifische Menüfunktionen ("Makros") implementieren und integrieren
• spezielle Reportfunktionen bereitstellen
• Funktionen zur Prüfung definierbarer Designregeln einführen
• automatische Routinen zur Bibliotheksbearbeitung entwickeln
• Automatismen zur Bauteilplatzierung oder für das Routing implementieren
• Programme für den CAM-Batchbetrieb bereitstellen
• Anwendungen des Neuronale Regelsystems implementieren
• firmenspezifische, relationale Datenbanken einbinden
• Werkzeuge zur Übernahme bzw. Ausgabe von Fremddaten implementieren

User Language-Programme können transparent in das BAE-Menüsystem eingebunden werden, und die Konfiguration der BAE-Software zum Aufruf häufig benötigter User Language-Programme über Tastendruck (Hotkey) ist ebenfalls möglich.

Da nicht jeder BAE-Anwender notgedrungen ein erfahrener Softwareentwickler sein muss, erwarten wir von unseren Kunden auch nicht, dass sie selbst extensive User Language-Programmierung betreiben (wenngleich sie dies natürlich tun können). Vielmehr versetzt uns das Konzept der User Language in die Lage, in kürzester Zeit und mit einem Höchstmaß an Flexibilität praktisch beliebige Anpassungen der BAE-Software an kundenspezifische Bedürfnisse vorzunehmen, ohne dass dadurch Änderungen im BAE-Software-Kernel und damit ein organisatorisch aufwändiger Software-Update notwendig wären. Damit können wir unseren Kunden die bestmögliche Unterstützung im Hinblick auf die Implementierung gewünschter Spezial- bzw. Zusatzfunktionen bieten. Sichtbares Resultat dieses einzigartigen Konzepts sind die zahlreichen, nach Kundenwünschen implementierten User Language-Programme, die integraler Bestandteil der BAE-Software sind. Da die User Language-Programme der BAE-Software im Quellcode ausgeliefert werden, kann der BAE-Anwender Anpassungen an firmenspezifische Bedürfnisse leicht selbst vornehmen. In diesem Zusammenhang sei auf das Kapitel 4 dieses Handbuchs verwiesen, welches Kurzbeschreibungen zu den mit der BAE-Software ausgelieferten User Language-Programmen sowie Informationen zur Installation bzw. Bereitstellung dieser Programme im Bartels AutoEngineer enthält.

1.1.2 Bestandteile

Die Bartels User Language besteht aus der Definition der Programmiersprache selbst, dem User Language Compiler, sowie dem User Language Interpreter.

Definition der User Language Programmiersprache

Bartels User Language ist eine auf dem Sprachumfang von C basierende Programmiersprache mit internen, aus der objektorientierte Programmierung (OOP) bekannten Erweiterungen (automatische Speicherverwaltung bei der Bearbeitung von Listen, spezieller Datentyp für Zeichenketten). Über spezielle Variablentypen ermöglicht Bartels User Language den Zugriff auf die Design-Datenbank (DDB) des Bartels AutoEngineer. Eine eingebundene Funktionsbibliothek erlaubt den Aufruf von Standard- und BAE-Systemfunktionen. Die User Language Programmiersprache ist in Kapitel 2 ausführlich beschrieben. Die Definition aller Variablentypen für den DDB-Zugriff ist in Anhang B dokumentiert. Anhang C enthält die vollständige Beschreibung der in die User Language eingebundenen Systemfunktionsbibliothek.

Bartels User Language Compiler

Der Bartels User Language Compiler (ULC) erlaubt die Übersetzung von Bartels User Language-Quelldateien in den für den Bartels User Language Interpreter ausführbaren Code. Der Compiler führt bei der Übersetzung eine ganze Reihe von Prüfungen hinsichtlich Datentypkompatibilität und Ausführbarkeit von Programmen durch und arbeitet wahlweise optimierend. Spezielle Compiler-Optionen erlauben die wahlweise Generierung von User Language-Libraries. Der integrierte Linker des User Language Compilers ermöglicht sowohl das statische Linken von User Language-Libraries (zur Compile-Zeit) als auch die Programmvorbereitung zum dynamischen Linken (während der Laufzeit). Eine ausführliche Beschreibung des User Language Compilers ist in Kapitel 3.2 enthalten.

Bartels User Language Interpreter

Der Bartels User Language Interpreter erlaubt (das dynamische Linken und) die Ausführung von kompilierten, d.h. durch den Bartels User Language Compiler generierten User Language-Programmen. Der Bartels User Language Interpreter ist derzeit in den Schaltplaneditor, den Layouteditor, den Autorouter, den CAM-Prozessor, das CAM-View-Modul und den Chipeditor des Bartels AutoEngineer eingebunden. D.h., aus diesen Programmteilen des Bartels AutoEngineer heraus ist der Start von User Language-Programmen möglich. Der Programmaufruf kann dabei wahlweise über eine spezielle Menüfunktion durch explizite Angabe des Programmnamens oder automatisiert über Tastendruck bzw. Programm-Modul-Startup erfolgen. Eine ausführlichere Beschreibung des User Language Interpreter finden Sie im Kapitel 3.3 dieses Handbuchs.

1.2 Charakteristische Eigenschaften der User Language

1.2.1 Bartels User Language im Vergleich zu C

Wie bereits einleitend erwähnt, ist Bartels User Language eine Programmiersprache, die auf dem Sprachumfang von C basiert. Kommentare sind wie in C üblich durch /* und */ zu begrenzen bzw. werden wie in C++ üblich mit // eingeleitet und durch das Zeilenende begrenzt.

Als elementare Datentypen sind char, int und double in Bartels User Language enthalten. Im Unterschied zu C fehlt hier der Datentyp float ebenso wie die Möglichkeit der Qualifizierung elementarer Datentypen (short, unsigned, long). Zeiger sind in der Bartels User Language nicht implementiert. An Stelle von char-Vektoren zur Darstellung von Zeichenketten kann in Bartels User Language der als elementar zu betrachtende Datentyp string verwendet werden. In Erweiterung zu C enthält Bartels User Language den ebenfalls als elementar zu betrachtenden speziellen Datentyp index. Über diesen Datentyp werden die Möglichkeiten des Zugriffs auf die Design-Datenbank (DDB) des Bartels AutoEngineer definiert. index kann dabei als Index in einen Vektor von DDB-Strukturen verstanden werden. Über einen speziellen Operator ist der Zugriff auf die Elemente der darüber adressierten Struktur möglich. Die index-Typen sowie die zugehörigen Strukturelemente sind vordefiniert (siehe Anhang B).

Vektoren werden im Gegensatz zu C dynamisch verwaltet, d.h. die Definition fester Vektorfeldgrenzen entfällt in der User Language. Ebenso besteht in der User Language die Möglichkeit, zusammengesetzte, komplexe Datentypen (Strukturen, Arrays) einander direkt zuzuweisen, sofern diese typkompatibel sind und dieselbe Dimensionierung aufweisen.

Die Vereinbarung der aus C bekannten Speicherklassen auto, extern und register ist in der Bartels User Language nicht explizit möglich. Grundsätzlich werden in der User Language alle innerhalb von Funktionen definierten Variablen der Speicherklasse auto zugeordnet, alle außerhalb von Funktionen definierten Variablen gelten als globale Variablen, sofern sie nicht explizit der Speicherklasse static zugeordnet sind. Ebenso gelten alle im Programmtext definierten Funktionen als global vereinbart, sofern sie nicht explizit der Speicherklasse static zugeordnet sind. Der Geltungsbereich globaler Variablen und Funktionen erstreckt sich auf das gesamte Programm, während als static deklarierte Variablen und Funktionen nur Gültigkeit im aktuellen Programmtext (nicht jedoch in einem noch zu linkenden Programmtext) besitzen.

Mechanismen zur Spracherweiterung mit Hilfe eines Makro-Preprozessors werden in Bartels User Language ebenfalls unterstützt; so stehen die aus C bekannten Preprozessor-Anweisungen #include, #define, #undef, #if, #ifdef, #ifndef, #else und #endif auch in der User Language zur Verfügung.

1.2.2 Datentypen, Konstanten, Variablen

Bartels User Language enthält die elementaren Datentypen char (Zeichen), int (ganzzahliger Wert), double (rationale Zahl doppelter Genauigkeit), string (Zeichenkette), sowie index (vordefinierter Index auf DDB-Struktur; siehe Anhang B). Daneben lassen sich aus den elementaren Datentypen abgeleitete Datentypen (Vektoren bzw. Arrays sowie Strukturen) definieren.

Bartels User Language erlaubt die Verwendung von Konstanten für die elementaren Datentypen. char-Konstanten sind dabei durch einfache, string-Konstanten durch doppelte Anführungszeichen zu begrenzen. Die in C übliche Verwendung des Backslashs (\) als Fluchtsymbol zur Angabe grafisch nicht darstellbarer Zeichen ist zulässig. Ganzzahlige Konstanten können wahlweise in Dezimal-, Oktal- oder Hexadezimalschreibweise dargestellt werden. Festkommakonstanten müssen einen Dezimalpunkt enthalten. Daneben ist auch die wissenschaftliche Gleitkommadarstellung mit Exponent erlaubt.

Konstante Ausdrücke bestehen aus Konstanten und Operatoren und werden bereits während der Übersetzung durch den Bartels User Language Compiler bewertet (Constant Expression Evaluation).

Alle Variablen müssen vereinbart werden, wodurch jeweils der Datentyp der Variablen, sowie deren Name festgelegt wird. Variablennamen müssen mit einem Buchstaben oder einem Unterstrich (_) beginnen und können nachfolgend beliebig viele Buchstaben, Ziffern oder Unterstriche aufweisen. Der Compiler unterscheidet bei der Verwendung von Buchstaben in Variablennamen zwischen Groß- und Kleinschreibung. Variablen können bereits bei deren Vereinbarung initialisiert werden. Wird eine nicht initialisierte Variable verwendet, dann gibt der Compiler ggf. eine entsprechende Warnmeldung aus. Der Interpreter hingegen wird in solchen Fällen die entsprechende Variable mit einem Nullwert initialisieren.

1.2.3 Operatoren, Zuweisungen

Bartels User Language verfügt über die aus C bekannten Operatoren (?:, +, -, *, /, %, >, >=, <, <=, ==, !=, &&, ||, !, ++, --, &, |, ^, <<, >>, ~). Die Reihenfolge des Vorrangs für die Bewertung von Operatoren entspricht ebenfalls der Programmiersprache C. Erscheinen Operanden mit verschiedenen Datentypen zusammen in Ausdrücken, dann werden deren Werte in einen gemeinsamen Datentyp umgewandelt. Derartige Umwandlungen finden allerdings nur dann statt, wenn sie möglich und auch sinnvoll sind (ansonsten Fehlermeldung durch den Compiler). Eine Erweiterung gegenüber C ergibt sich aus der Möglichkeit, den Additionsoperator + sowie die Vergleichsoperatoren (>, >=, <, <=, ==, !=) direkt auf den Datentyp string anzuwenden.

Eine Zuweisung erfolgt üblicherweise durch den =-Operator, wobei der Ausdruck auf der rechten Seite des Gleichheitszeichens der Variablen auf der linken zugewiesen wird. Die in C üblichen zusammengesetzten Zuweisungsoperatoren (+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=) sind auch in Bartels User Language zulässig.

1.2.4 Kontrollstrukturen

Durch Kontrollstrukturen wird die Reihenfolge der auszuführenden Aktionen definiert. Bartels User Language erlaubt alle aus C bekannten Kontrollstrukturen außer der goto-Anweisung sowie der Definition von Marken. Die verfügbaren Kontrollstrukturen sind somit if bzw. if-else, switch, while, for, do-while, break und continue. Eine Erweiterung gegenüber C bildet die forall-Kontrollstruktur, mit der ein repetitives Abarbeiten von index-Datentyp-Variablen möglich ist.

1.2.5 Programmfluss, Funktionen

Wie C ermöglicht auch Bartels User Language die Zerlegung großer Problemstellungen in kleinere mit Hilfe von Funktionen. Zu unterscheiden ist dabei zwischen den in Bartels User Language eingebundenen Systemfunktionen (siehe Anhang C) und den Funktionen, die der Programmierer innerhalb eines Programms selbst definiert (Anwenderfunktionen). Die Definition und Deklaration der Anwenderfunktionen mit ihren Funktionsparametern entspricht der Vorgehensweise in C. Ebenso ist die Anwenderfunktion mit dem Namen main immer die erste Funktion, die bei einem Programmlauf aufgerufen wird (d.h. die Funktion main muss i.d.R. definiert sein, damit ein User Language-Programm überhaupt "etwas tut"). Im Gegensatz zu C unterscheidet Bartels User Language bei der Bewertung von an Funktionen übergebenen Parametern nicht zwischen "Call-By-Value" und "Call-By-Reference"; alle Parameter werden jeweils durch das "Call-By-Reference"-Verfahren bewertet, wodurch selbstverständlich nicht (wie sonst in C üblich) mit Zeigern gearbeitet werden muss, um geänderte Parameterwerte an einen Funktionsaufrufer zurückzumelden.

1.2.6 Integrierte Spezialfunktionen

Bartels User Language stellt dem Anwender einige spezielle Werkzeuge zur Verfügung, die es aufgrund ihres umfangreichen Funktionsspektrums und ihrer außerordentlichen Mächtigkeit verdienen, an dieser Stelle gesondert erwähnt zu werden.

So ist in die Bartels User Language ein BNF-Precompiler zur Realisierung von Interfaceprogrammen für die Bearbeitung von Fremddatenformaten integriert. Unter Verwendung der zugehörigen Scanner- und Parserfunktionen lassen sich in einfacher und eleganter Weise Programme zur Verarbeitung praktisch beliebiger ASCII-Datenformate implementieren (siehe hierzu auch Kapitel 2.6.4 dieses Handbuchs).

Bartels User Language enthält des Weiteren SQL (Structured Query Language)-Funktionen zur Verwaltung Relationaler Datenbanken. Damit stehen dem Anwender Softwaretools zur Programmierung von Datenbankmanagementsystemen zur Verfügung. Die entsprechenden SQL-Zugriffsfunktionen erlauben es, z.B. eine Datenbank für Bauteildaten zur Variantenverwaltung in den Bartels AutoEngineer integrieren. Damit lassen sich in einfacher Weise "was wäre wenn"-Analysen (Kosten, Lagerbestand, usw.) für verschiedene Varianten eines Layouts durchführen, sowie komfortable Datenbankfunktionen zur schnellen Auswahl geeigneter Bauteile mit einer kontrollierten Zuordnung von Gehäusebauform und Bauteilwert implementieren. Dies ist jedoch nur ein Beispiel aus dem breiten Anwendungsspektrum; selbstverständlich lassen sich auch Datenbanksysteme zur Projektverwaltung, zum Projektmanagement, zur Versionsverwaltung, zur Produktionsplanung und -steuerung (PPS), zur Adressverwaltung, zur Verwaltung von Lieferantenverzeichnissen und Kundendateien, usw. realisieren. Anhang C dieses Handbuchs enthält die Beschreibungen der SQL-Systemfunktionen.

2 Sprachbeschreibung

Inhalt

2.1.1

Ein erstes User Language Programm

2.1.2

Variablen, Arithmetik und Funktionen

2.1.3

Vektoren und Kontrollstrukturen

2.2.1

Zwischenraum

2.2.2

Identifier

2.2.3

Konstanten und konstante Ausdrücke

2.2.4

Terminalzeichen-Sequenzen

2.3.1

Datentypen

2.3.2

Variablen

2.3.3

Funktionen

2.3.4

Regeln zum Geltungsbereich

2.4.1

Primäre Ausdrücke

2.4.2

Unitäre Ausdrücke

2.4.3

Binäre Ausdrücke

2.4.4

Liste von Ausdrücken

2.4.5

Vorrang und Reihenfolge der Bewertung

2.5.1

Sequentielle Programm-Elemente

2.5.2

Alternativen

2.5.3

Repetitionen

2.5.4

Kontrollfluss-Steuerung

2.6.1

Dateieinbindung

2.6.2

Konstantendefinition

2.6.3

Bedingte Übersetzung

2.6.4

BNF-Precompiler

2.6.5

Programmaufruftyp und Undo-Mechanismus

2-1

Darstellung von Sonderzeichen

2-2

Reservierte Worte

2-3

Operatoren

2-4

Operator Vorrang und Assoziativität

2.1 Einführung in die User Language Programmierung

An dieser Stelle sollen anhand kleiner Programmbeispiele die wichtigsten Sprachelemente der User Language kurz vorgestellt werden, ohne zunächst Wert auf Vollständigkeit zu legen bzw. auf Details oder gar Ausnahmeregelungen einzugehen. Ziel dabei ist, möglichst schnell die Vorgehensweise bei der User Language Programmierung aufzuzeigen.

2.1.1 Ein erstes User Language Programm

Als erstes soll ein Programm erstellt werden, welches lediglich eine Meldung ausgibt und dann auf eine Eingabe wartet, um den Programmlauf abzubrechen. Dies ist im Übrigen bereits ein Programmkonstrukt, das innerhalb des Bartels AutoEngineer relativ häufig benötigt wird. Wie Sie bereits aus der Einleitung wissen, muss ein User Language-Programm mindestens aus der main-Funktion bestehen. Was innerhalb der main-Funktion benötigt wird, ist eine Anweisung, die die gewünschte Meldung ausgibt, sowie eine Anweisung, die eine Benutzerabfrage aktiviert. Beide Anweisungen werden durch den Aufruf entsprechender User Language Systemfunktionen (printf und askstr) realisiert. Diese Systemfunktionen sind dem Compiler bekannt, und in den Interpreter eingebunden, d.h. der Programmierer muss lediglich wissen, wie diese Funktionen aufzurufen sind, und was sie tun (diese Information kann dem Anhang C dieses Handbuchs entnommen werden). Erstellen Sie nun mit Ihrem Texteditor folgendes User Language-Programm und speichern Sie dieses unter dem Dateinamen ulprog.ulc ab (an der File-Extension .ulc erkennt der Compiler, dass es sich um ein User Language Programm handelt):

main()
{
      printf("User Language Program");
      askstr("Press ENTER to continue ",1);
}

Wie Sie sehen, besteht das Programm lediglich aus der Definition der Funktion main. Innerhalb der runden Klammern nach dem Funktionsnamen stehen normalerweise die formalen Parameter der Funktion. Um den Funktionsnamen von anderen Variablennamen zu unterscheiden, sind diese Klammern auch anzugeben, wenn, wie in obigem Beispiel, keine Parameter existieren. Innerhalb der geschweiften Klammern befindet sich der Rumpf der Funktion, d.h. die Anweisungen, die die Funktion ausführen soll. Jede Anweisung wird durch ein Semikolon (;) abgeschlossen. Die erste Anweisung innerhalb der Funktion main ist der Aufruf der Funktion printf, was an der nachfolgenden runden Klammer zu erkennen ist. Als Argument bzw. Parameter wird an printf (in doppelten Anführungszeichen) eine konstante Zeichenkette übergeben, die das Programm bei fehlerfreier Übersetzung und Ausführung am Bildschirm ausgibt. Die zweite Anweisung ist ein Aufruf der Funktion askstr. Diese Funktion gibt in der Eingabe- bzw. Mitteilungszeile des Bartels AutoEngineer ihr erstes Argument in Form eines Prompts aus und wartet auf die Eingabe einer Zeichenkette durch den Anwender. Der zweite Parameter zu askstr gibt dabei die maximal zulässige Länge der einzugebenden Zeichenkette an. Der Aufruf von askstr ist zugleich die letzte Anweisung des Programms, d.h. nach der Bearbeitung des askstr-Aufrufs wird das Programm beendet. Wenn das Programm fertig codiert und unter ulprog.ulc abgespeichert ist, kann es mit folgendem Aufruf des User Language Compilers übersetzt werden:

ulc ulprog

Falls keine Fehler auftreten, gibt der Compiler die folgende Meldung auf dem Bildschirm aus:

==============================
BARTELS USER LANGUAGE COMPILER
==============================

Quellcodedatei "ulprog.ulc" wird kompiliert...
Programm 'ulprog' erfolgreich generiert.
Quellcodedatei "ulprog.ulc" erfolgreich kompiliert.

Keine Fehler, keine Warnungen.
User Language Compiler-Lauf erfolgreich beendet.

Der Compiler hat das Programm übersetzt und unter dem Namen ulprog in der Datei ulcprog.vdb im Bartels AutoEngineer Programmverzeichnis abgespeichert. Jetzt kann das Programm durch den User Language Interpreter ausgeführt werden. Hierzu ist z.B. der Schaltplaneditor des Bartels AutoEngineer aufzurufen und die Funktion Anwenderfunktion im Menü Datei zu aktivieren. Auf die Abfrage nach dem Namen des auszuführenden Programms ist anschließend ulprog einzugeben:

Datei

Anwenderfunktion

Programmname ?

ulprog

Der Grafikarbeitsbereich des AutoEngineer wird in den Textmodus geschaltet und es wird die Meldung User Language Program angezeigt. Anschließend wird im Eingabefenster der Prompt Press ENTER to continue angezeigt. Betätigt der Anwender daraufhin die Return-Taste, dann wird das User Language-Programm beendet und der Grafikarbeitsbereich wieder in den Grafikmodus zurückgeschaltet.

2.1.2 Variablen, Arithmetik und Funktionen

Anhand des nächsten Beispiels sollen eine ganze Reihe weiterer spezifischer Eigenschaften der User Language veranschaulicht werden. Das folgende Programm überprüft einige durch ihren Mittelpunkt und ihren Radius definierte Kreise daraufhin, ob sie sich überlappen (Bohrdatentest?!), und gibt entsprechende Meldungen aus:

// Circle Test Program

double tol=0.254*5;           // Tolerance

struct pos {                  // Position descriptor
      double x;               // X coordinate
      double y;               // Y coordinate
      };

struct circle {               // Circle descriptor
      double rad;             // Circle radius
      struct pos c;           // Circle position
      };

// Main program
main()
{
      // Define three circles
      struct circle c1 = {  4.5, { 19.4, 28.3} };
      struct circle c2 = { 17.0, { 37.6, 9.71} };
      struct circle c3 = { 1.5E01, { 25, 0.2e2} };
      // Perform circle test
      printf("Circle 1 - 2 overlap : %d\n",circletest(c1,c2));
      printf("Circle 1 - 3 overlap : %d\n",circletest(c1,c3));
      printf("Circle 2 - 3 overlap : %d\n",circletest(c2,c3));
      // Prompt for continue
      askstr("Press ENTER to continue ",1);
}

int circletest(c1,c2)
// Circle test function
// Returns: nonzero if overlapping or zero else
struct circle c1,c2           /* Test circles 1 and 2 */;
{
      double d                /* Distance value */;
      // Get circle center point distances
      d=distance(c1.c,c2.c);
      // Error tolerant check distance against radius sum
      return(d<=(c1.rad+c2.rad+tol));
}

double distance(p1,p2)
// Get distance between two points
// Returns: distance length value
struct pos p1                 /* Point 1 */;
struct pos p2                 /* Point 2 */;
{
      double xd=p2.x-p1.x     /* X distance */;
      double yd=p2.y-p1.y     /* Y distance */;
      // Calculate and return distance
      return(sqrt(xd*xd+yd*yd));
}

Obiger Quelltext enthält eine Reihe von Kommentaren, die durch /* und */ eingeklammert sind; diese Kommentare dürfen sich über mehrere Zeilen erstrecken, aber sie dürfen nicht verschachtelt werden. Ein anderer Typ von Kommentar beginnt mit // und erstreckt sich jeweils bis zum Zeilenende. Sie sollten sich angewöhnen, Ihre Programme mit derartiger Inline-Dokumentation zu versehen, damit der Programmcode gut verständlich bleibt und somit - auch durch dritte - leichter gepflegt bzw. weiterentwickelt werden kann.

Das Programm enthält weiterhin eine Reihe von Variablendefinitionen. Variablen müssen grundsätzlich vor ihrer Verwendung definiert werden. Dabei wird sowohl der Datentyp als auch der Variablenname festgelegt. Unterschieden wird zwischen globalen Variablen, lokalen Variablen und Funktionsparametern. Der Geltungsbereich globaler Variablen erstreckt sich über das gesamte Programm. Lokale Variablen sind nur innerhalb der Funktion, in der sie definiert wurden, gültig. Funktionsparameter dienen dazu, Werte an Funktionen zu übergeben. In obigem Beispiel wird als einzige globale Variable tol mit dem Datentyp double definiert. Beispiele für lokale Variablen sind die double-Variablen xd und yd in der Funktion distance. Funktionsparameter sind z.B. c1 und c2 in der Funktion circletest. Diese sind von dem speziell definierten zusammengesetzten struct-Datentyp circle. Initialisierungen globaler und lokaler Variablen lassen sich bereits bei deren Deklaration durchführen. Beispiele hierfür sind die globale Variable tol sowie die lokalen Variablen xd und yd der Funktion distance. Auch zusammengesetzte Datentypen lassen sich initialisieren, wie die Beispiele für die lokalen struct-Variablen c1, c2 und c3 der Funktion main zeigen. Bei der Variablendeklaration besteht darüber hinaus die Möglichkeit, gleich eine ganze Liste von Variablennamen anzugeben (siehe Parameterdeklaration für c1 und c2 in der Funktion circletest).

Die Berechnung von Werten erfolgt über Ausdrücke, wobei das Gleichheitszeichen (=) als Zuweisungsoperator fungiert.

Bei der Definition von Funktionen ist ebenfalls ein Datentyp zu spezifizieren. In obigem Beispiel ist die Funktion distance vom Typ double, die Funktion circletest vom Typ int. Wird die Datentypspezifikation - wie bei der Funktion main - weggelassen, dann wird deren Typ automatisch auf int gesetzt. Ein spezieller Datentyp für Funktionen ist void. Jede Funktion außer den void-Funktionen liefert einen zum Funktionsdatentyp kompatiblen Rückgabewert. Die Übergabe des Rückgabewerts geschieht mit der return-Funktion, welche gleichzeitig die Funktionsausführung beendet.

2.1.3 Vektoren und Kontrollstrukturen

An dieser Stelle sei abschließend ein Beispiel für die Verwendung von Vektoren und Kontrollstrukturen aufgeführt. Das nachfolgende Programm wandelt eine ganze Liste von Integerwerten in Strings um und gibt diese aus:

// Integer list
int intary[]={ 0,17,-12013,629,0770,0xFF,-16*4+12 };

// Main program
main()
{
      int i                   /* Loop control variable */;
      // Set last integer value
      intary[10]=(-1);
      // Loop through integer list
      for (i=0;i<=10;i++)
              // Print integer and integer string
              printf("%8d : \"%s\"\n",intary[i],inttostr(intary[i]));
      // Prompt for continue
      askstr("Press ENTER to continue ",1);
}

string inttostr(int intval)
// Convert integer value to a string
// Returns: resulting string
{
      string resstr=""        /* Result string */;
      int n=intval,i=0        /* Integer value, loop counter */;
      char sign               /* Sign character */;
      // Test for negative integer value
      if (n==0)
              // Return zero integer string
              return("0");
      else if (n>0)
              // Set sign to plus character
              sign='+';
      else {
              // Make integer value positive
              n=-n;
              // Set sign to minus character
              sign='-';
              }
      // Build result string
      do {    // Get and append next character
              resstr[i++]=n%10+'0';
              } while ((n/=10)!=0);
      // Append zeros
      while (i++<15)
              resstr+='0';
      // Append sign character
      resstr+=sign;
      // Reverse string
      strreverse(resstr);
      // Return string result
      return(resstr);
}

In obigem Programm wird ein Vektor aus Integerwerten (globale int-Variable intary) deklariert und dabei auch bereits (teilweise) initialisiert. Wie leicht zu erkennen ist, definiert das eckige Klammernpaar nach dem Variablennamen intary einen eindimensionalen int-Vektor. Mehrdimensionale Vektoren sind durch entsprechendes Anfügen weiterer eckiger Klammernpaare (intary[][]...[]) zu deklarieren. Zu beachten ist dabei, dass die Angabe einer Feldlänge entfällt. Dies resultiert aus der Fähigkeit der User Language, Vektoren dynamisch zu verwalten, d.h. sowohl dem Compiler als auch dem Interpreter genügt die Information über die Dimension des Vektors. Allerdings erfolgen doch einige Prüfungen, die den Zugriff auf nicht existente Vektorelemente (und damit eine Speicherzugriffsverletzung) unterbinden. So erkennt der Compiler z.B., wenn versucht wird, über einen konstanten, negativen (also ungültigen) Index auf ein Vektorelement zuzugreifen. Ebenso prüft der Interpreter Vektorindizes, die außerhalb des aktuell belegten Vektorfeldbereiches liegen. Beachten Sie hierbei, dass der Index mit dem Wert 0 auf das erste Element eines Vektors verweist.

Eine spezielle Form eines Vektors stellt der Datentyp string dar. User Language erlaubt die direkte Zuweisung von Vektoren kompatiblen Datentyps und gleicher Dimension. Dies wurde bei der Initialisierung der lokalen Variable resstr in der Funktion inttostr ebenso wie bei der Definition dieser Funktion als string und beim Setzen entsprechender Rückgabewerte in den return-Aufrufen ausgenutzt. Zudem lässt sich der Additionsoperator direkt auf string-Datentypen anwenden; das Resultat entspricht dabei einem durch Aneinanderfügen der beiden Additionsoperatoren erzeugten string.

Obiges Programmbeispiel enthält einige Kontrollstrukturen. So wird in der Funktion main über eine for-Schleife die Vektorvariable intary abgearbeitet. In der Funktion inttostr werden eine while- und eine do-while-Schleife verwendet, um die string-Variable resstr zu manipulieren. Des Weiteren enthält die Funktion inttostr eine if-Kontrollstruktur, die in Abhängigkeit vom Wert der lokalen Variablen n jeweils in einen entsprechenden Programmblock verzweigt.

2.2 Konventionen

In der User Language sind die Wortklassen Zwischenraum, Identifier, Konstante, reserviertes Wort und Operator definiert.

2.2.1 Zwischenraum

Unter die Wortklasse Zwischenraum fallen sowohl Leerstellen, Tabulatorzeichen, Zeilentrenner als auch Kommentare. Kommentare beginnen mit den Zeichen /* und enden mit */; diese Kommentare dürfen nicht verschachtelt sein. Ein weiterer Typ von Kommentar beginnt mit den Zeichen // und erstreckt sich bis zum Zeilenende. Der User Language Compiler wertet Zwischenräume lediglich zur Trennung direkt benachbarter Identifier und reservierter Worte aus; ansonsten werden alle Zwischenräume ignoriert.

2.2.2 Identifier

Ein Identifier ist der Name einer Variablen, einer Funktion oder einer symbolischen Konstanten. Jeder Identifier darf aus einer Folge von Buchstaben und Ziffern bestehen, wobei das erste Zeichen immer ein Buchstabe sein muss. Der Unterstrich (_) zählt dabei zu den Buchstaben. Der User Language Compiler unterscheidet bei der Auswertung von Identifiern zwischen Groß- und Kleinbuchstaben. Es besteht die Einschränkung, dass Identifier nicht mit reservierten Worten (siehe unten) identisch sein dürfen.

Beispiele:

X_coord   value   P4   File_Name   _euklid

2.2.3 Konstanten und konstante Ausdrücke

Nachfolgend sind die in der User Language definierten Konstanten beschrieben. Jeder Konstanten-Typ ist zugleich auch einem Datentyp zugeordnet.

Ganzzahlige Konstanten

Ganzzahlige Konstanten sind dem Datentyp int zugeordnet. Sie bestehen aus einer Folge von Ziffern und werden üblicherweise dezimal interpretiert. Falls die Ziffernfolge mit 0 (Ziffer Null) beginnt, wird sie oktal, d.h. in Basis 8 interpretiert (die Ziffern 8 und 9 sind in diesem Fall nicht zulässig). Beginnt die Ziffernfolge mit 0x bzw. 0X (Ziffer Null, Buchstabe x), dann wird sie hexadezimal, d.h. in Basis 16 interpretiert, wobei dann die Buchstaben a bis f bzw. A bis F als hexadezimale Ziffern mit den Werten 10 bis 15 gelten. Ganzzahlige negative Konstanten gibt es nicht; vielmehr stellt das Minus-Zeichen einen Operator dar, der in Verbindung mit einer ganzzahligen Konstante einen konstanten Ausdruck (siehe unten) bildet.

Beispiele:

1432   073   0xF4A5   9

Gleitkomma-Konstanten

Gleitkomma-Konstanten sind dem Datentyp double zugeordnet. Sie bestehen aus einem ganzzahligen Teil, einem Dezimalpunkt, einem Dezimalbruch, dem Zeichen e bzw. E (Buchstabe e) und einem ganzzahligen Exponenten mit optionalem Vorzeichen. Ganzzahliger Teil, Dezimalbruch sowie Exponent sind dabei Ziffernfolgen. Genau einer der Teile vor oder nach dem Dezimalpunkt (.) darf fehlen; entweder der Dezimalpunkt oder der Exponent beginnend mit dem Buchstaben e darf fehlen.

Beispiele:

2.54   .78   4.   4.1508E-3   0.81037e6   17228E5

Zeichen-Konstanten

Zeichen-Konstanten sind dem Datentyp char zugeordnet. Sie bestehen aus einem einzelnen, in einfache Anführungsstriche (Apostroph) eingeschlossenen Zeichen. Der Wert dieser Konstante ist der numerische Wert des Zeichens im Zeichensatz der Maschine, auf der das User Language-Programm ausgeführt wird.

Tabelle 2-1 enthält eine Liste von Sonderzeichen-Darstellungen mit Hilfe des Fluchtsymbols \ (Backslash).

Tabelle 2-1: Darstellung von Sonderzeichen

Beliebige Bitmuster können durch die Angabe des Fluchtsymbols, gefolgt von bis zu drei oktalen Ziffern spezifiziert werden. Ein Spezialfall dieser Konstruktion ist das Nullzeichen (NUL, \0).

Zeichenketten-Konstanten

Zeichenketten-Konstanten (oder auch String-Konstanten) sind dem Datentyp string zugeordnet. Sie bestehen aus einer Folge von Zeichen umgeben von Doppel-Anführungsstrichen. Der Compiler legt ein NUL Zeichen (\0) am Ende der String-Konstanten ab, damit der Interpreter das Ende des konstanten Strings finden kann. Bei der Spezifikation von String-Konstanten muss auch der Doppel-Anführungsstrich mit einem Fluchtsymbol angegeben werden. Daneben existieren dieselben Fluchtsymbol Kombinationen wie für die Zeichen-Konstanten.

Beispiele:

"IC1"   "4.8 kOhm"   "This is a string with Newline\n"

Konstante Ausdrücke

Ein konstanter Ausdruck ist ein Ausdruck, der nur aus konstanten Werten und Operatoren zusammengesetzt ist. Solche Ausdrücke werden bereits vom Compiler bewertet (CEE, Constant Expression Evaluation) und müssen somit nicht erst zur Laufzeit durch den Interpreter berechnet werden. Dies bedeutet, dass, wo immer Konstanten benötigt werden, statt dessen auch entsprechende konstante Ausdrücke verwendet werden können, ohne dass sich dadurch Nachteile hinsichtlich der Programmgröße oder der Programmlaufzeit ergeben.

Beispiele:

int i=19-(010+0x10);                  CEE: int i=-5;
double d=-(4.7+2*16.3);               CEE: double d=-37.3;
string s="Part"+' '+"IC1";            CEE: string s="Part IC1";

2.2.4 Terminalzeichen-Sequenzen

Reservierte Worte

Tabelle 2-2 enthält die Liste der Identifier, die in der Bartels User Language als Schlüsselwörter reserviert sind. Diese Identifier dürfen nur in ihrer vordefinierten Bedeutung verwendet werden:

Tabelle 2-2: Reservierte Worte

Operatoren

Die in Tabelle 2-3 aufgeführten Zeichen(-Sequenzen) sind in der Bartels User Language als Operatoren definiert und lösen je nach Kontext spezielle Aktionen aus:

Tabelle 2-3: Operatoren

2.3 Datentypen und Definitionen

2.3.1 Datentypen

Die Bartels User Language stellt die folgenden elementaren Datentypen zur Verfügung:

Daneben ist die Verwendung folgender zusammengesetzter Datentypen möglich:

Datentyp-Konvertierung

Verschiedene Operatoren können implizite Datentypumwandlungen verursachen. So setzen eine Reihe arithmetischer Operationen definierte Datentypen bzw. Datentyppaare für ihre Operanden voraus. Ebenso wird bei der Zuweisung eines Wertes an eine Variable oder der Übergabe von Funktionsparametern eine entsprechende Datentypkompatibilität verlangt. Sofern an irgendeiner Stelle im Programm die geforderte Kompatibilität nicht vorliegt, wird versucht, den Wert des betroffenen Operanden in den gewünschten Datentyp zu überführen (man spricht von einem "type cast"). Diese Typkonvertierung läuft nach folgenden Regeln ab: Zulässige Umwandlungen ohne Informationsverlust sind char in int oder char in string, sowie int in double; ebenfalls zulässige Umwandlungen - jedoch mit möglichem Informationsverlust - sind int in char, sowie double in int. Der Compiler gibt Fehlermeldungen aus, wenn auch unter Ausnutzung der Typkonvertierungsregeln keine Typkompatibilität erreicht werden kann.

2.3.2 Variablen

Alle globalen und lokalen Variablen müssen vor ihrem Gebrauch deklariert werden, damit sowohl ihr Datentyp als auch ihr Name definiert sind. Durch derartige Vereinbarungen wird festgelegt, wie einzelne, vom Benutzer eingeführte Namen durch die User Language zu interpretieren sind. Jede Vereinbarung besteht aus einer Datentypspezifikation sowie einer Liste von Deklaratoren; die Deklaratoren wiederum bestehen aus dem Variablennamen sowie wahlweise einer Initialisierung der Variablen.

Elementare Datentypen

Beispiel für die Deklaration von char-Variablen:

char c;
char TAB = '\t', NEWLINE = '\n';

In obigem Beispiel werden die char-Variablen c (nicht initialisiert) sowie TAB und NEWLINE (initialisiert mit dem Tabulator- bzw. dem Zeilenvorschub-Zeichen) deklariert.

Beispiel für die Deklaration von int-Variablen:

int i, MAXLINELEN = 80;
int pincount = 0;

In obigem Beispiel werden die int-Variablen i (nicht initialisiert) und MAXLINELEN (initialisiert mit dem Wert 80), sowie pincount (initialisiert mit 0) vereinbart.

Beispiel für die Deklaration von double-Variablen:

double x_coord, y_coord;
double MMTOINCH = 1.0/25.4;
double starttime = clock();

In obigem Beispiel werden die double-Variablen x_coord und y_coord (nicht initialisiert), MMTOINCH (initialisiert mit einem numerischen Ausdruck), sowie starttime deklariert; die Variable starttime wird initialisiert mit dem Resultatwert der (System-)Funktion clock, welche die Prozessor-Zeit zurückgibt.

Beispiel für die Deklaration von string-Variablen:

string s1;
string ProgName = "TESTPROGRAM", ProgVer = "V1.0";
string ProgHeader = ProgName+"\t"+ProgVer;

In obigem Beispiel werden die string-Variablen s1 (nicht initialisiert), ProgName und ProgVer (initialisiert mit TESTPROGRAM und V1.0), sowie ProgHeader deklariert; ProgHeader wird dabei mit einem Ausdruck initialisiert, der sich durch Aneinanderfügen der string-Variablen ProgName, des Tabulatorzeichens, sowie der string-Variablen ProgVer ergibt.

Beispiel für die Deklaration von index-Variablen:

index L_MACRO macro;
index L_CNET net1, net2;

In obigem Beispiel werden die index-Variablen macro (vom index-Variablentyp L_MACRO) sowie net1 und net2 (vom index-Variablentyp L_CNET) vereinbart. Bei der Deklaration von index-Variablen besteht die Spezifikation des Datentyps aus dem Schlüsselwort index und zusätzlich dem Namen des index-Variablentyps (hier L_MACRO bzw. L_CNET). Die Namen für die index-Variablentypen sind vordefiniert (siehe Anhang B). Es muss sichergestellt sein, dass in einem Programm nur zueinander kompatible index-Variablentypen verwendet werden. Dies beruht auf der Tatsache, dass über index-Datentypen der Zugriff auf entsprechende Einträge aus der Design-Datenbank (DDB) des Bartels AutoEngineer definiert wird; die Verfügbarkeit dieser DDB-Einträge unterscheidet sich je nach Interpreterumgebung (im Schaltplaneditor sind andere Datentypen definiert als im Layout). Bei der Verwendung zueinander nicht kompatibler index-Variablentypen im selben Programm gibt der User Language Compiler eine entsprechende Fehlermeldung aus und erzeugt keinen Code. Ähnlich verhält sich der User Language Interpreter; beim Versuch ein User Language-Programm aufzurufen, das zur Interpreterumgebung inkompatible index-Datentyp-Referenzen enthält, gibt das System eine entsprechende Fehlermeldung aus und führt das betreffende Programm nicht aus. Die Information über die Kompatibilität der index-Datentypen ist dem Anhang A bzw. dem Anhang B zu entnehmen.

Vektoren

Unter einem Vektor, auch bezeichnet als Feld oder Array, versteht man die Zusammenfassung einzelner Elemente gleichen Datentyps. Bei der Deklaration von Vektorvariablen wird neben der Spezifikation des Datentyps und der Definition des Variablennamens zusätzlich die Angabe der Vektordimension benötigt. Diese Dimensions-Angabe erfolgt durch Anfügen eckiger Klammern an den Variablennamen, wobei jeweils ein Klammernpaar einer Dimension entspricht. Bei der Initialisierung von Vektor-Elementen sind die Initialisierungswerte durch Kommata zu trennen, und jede Vektordimension ist in geschweifte Klammern einzuschließen.

Beispiel für die Deklaration von Vektor-Variablen:

int intary[], intfield[][][];
double valtab[][] = {
      { 1.0, 2.54, 3.14 },
      { 1.0/valtab[0][1], clock() }
      };
string TECHNOLOGIES[] = {
      "TTL", "AC", "ACT", "ALS", "AS", "F",
      "H", "HC", "HCT", "HCU", "L", "LS", "S"
      };

Obiges Beispiel enthält die Deklarationen der int-Vektoren intary und intfield (ein- bzw. dreidimensional), des zweidimensionalen double-Vektors valtab, sowie des eindimensionalen string-Vektors TECHNOLOGIES. In den Deklarationen für valtab und TECHNOLOGIES sind Initialisierungen angegeben, die den folgenden Zuweisungen entsprechen:

valtab[0][0] = 1.0;
valtab[0][1] = 2.54;
valtab[0][2] = 3.14;
valtab[1][0] = 1.0/valtab[0][1];
valtab[1][1] = clock();
TECHNOLOGIES[0] = "TTL";
TECHNOLOGIES[1] = "AC";
TECHNOLOGIES[2] = "ACT";
:
TECHNOLOGIES[11] = "LS";
TECHNOLOGIES[12] = "S";

Es sei an dieser Stelle nochmals darauf hingewiesen, dass in der User Language der elementare Datentyp string einem eindimensionalen char-Vektor entspricht. Die Deklarationen

string s;

und

char s[];

sind also äquivalent.

Strukturen

Unter einer Struktur versteht man die Zusammenfassung mehrerer, jeweils durch Name und Datentyp definierter Elemente, die in einem bestimmten verarbeitungstechnischen oder auch nur logischen Zusammenhang stehen. Bei der Vereinbarung von Strukturen unterscheidet man die Strukturdefinition und die Strukturdeklaration. Die Strukturdefinition besteht aus dem Schlüsselwort struct, dem Namen der Strukturdefinition, und - in geschweiften Klammern - den Definitionen der Strukturelemente. Die Strukturdeklaration besteht aus dem Schlüsselwort struct, dem Namen einer gültigen Strukturdefinition, sowie dem Namen der Variablen, die der Strukturdefinition zugeordnet wird. Strukturdefinition und Strukturdeklaration können zusammengefasst werden, wobei dann auch der Name für die Strukturdefinition entfallen kann. Initialisierungen innerhalb von Strukturdeklarationen sind in der aus den Vektordeklarationen bekannten Nomenklatur zulässig.

Beispiel für die Vereinbarung von Strukturen:

// Structure declarations

struct coordpair {
      double x
      double y;
      };

struct coordpair elementsize = {
      bae_planwsux()-bae_planwslx(),
      bae_planwsuy()-bae_planwsly()
      };

struct elementdes {
      string fname, ename;
      int class;
      struct coordpair origin, size;
      } element = {
              bae_planfname(),
              bae_planename(),
              bae_planddbclass(),
              {
                      bae_planwsnx(),
                      bae_planwsny()
                      },
              elementsize
              };

struct {
      string id, version;
      struct {
              int day;
              string month;
              int year;
              } reldate;
      } program = {
              "UL PROGRAM",
              "Version 1.1",
              { 4, "July", 1992 }
              };

Obiges Beispiel enthält die Definition der Struktur coordpair, die Deklaration der Variablen elementsize (Struktur vom Typ coordpair), die Definition der Struktur elementdes, die Deklaration der Variablen element (Struktur vom Typ elementdes), sowie die Deklaration der Strukturvariablen program. Die in den Deklarationen für elementsize, element und program enthaltenen Initialisierungen entsprechen den folgenden Zuweisungen:

elementsize.x=bae_planwsux()-bae_planwslx();
elementsize.y=bae_planwsuy()-bae_planwsly();
element.fname=bae_planfname();
element.ename=bae_planename();
element.class=bae_planddbclass();
element.origin.x=bae_planwsnx();
element.origin.y=bae_planwsny();
element.size=plansize;
program.id="UL PROG";
program.version="Version 1.1";
program.reldate.day=4;
program.reldate.month="July";
program.reldate.year=1992;

Auch die Definition von Vektoren aus Strukturen bzw. die Verwendung von Vektordatentypen innerhalb von Strukturen ist möglich, wie das folgende Beispiel demonstriert:

struct drilldef {
      index L_DRILL drilltool;
      struct { double x, y; } drillcoords[];
      } drilltable[];

Datentypumbenennung

Bartels User Language verfügt über einen Mechanismus zur Umbenennung von Datentypen. Dabei handelt es sich nicht um die Schaffung eines neuen Datentyps, sondern lediglich um die Vergabe eines zusätzlichen Namens für einen bereits bekannten Typ. Eine derartige Typumbennung erfolgt durch die Angabe des Schlüsselwortes typedef gefolgt von der Spezifikation des Datentyps sowie dem zur Bezeichnung dieses Datentyps zusätzlich einzuführenden Namen. Ein mit typedef eingeführter Name kann anschließend zur Typspezifikation bei der Deklaration von Variablen, Funktionen und Funktionsparametern verwendet werden.

Beispiel für Typ-Umbennungen:

typedef index L_CNET NETLIST[];
typedef int IARY[];
typedef IARY MAT_2[];
typedef struct {
      int pointcount;
      struct {
              int t;
              double x,y;
              } pointlist[];
      } POLYLIST[];
MAT_2 routmatrix;
NETLIST netlist;
POLYLIST polygonlist;

In obigem Beispiel werden die drei Variablen routmatrix (zweidimensionaler int-Vektor), netlist (eindimensionaler index-Vektor vom Typ L_CNET), sowie polygonlist (eindimensionaler Vektor aus Strukturen, die ihrerseits ein int-Element und einen struct-Vektor enthalten) deklariert.

2.3.3 Funktionen

Bei komplexen Operationen und Berechnungen ist es meist nicht notwendig, zu wissen, wie das Ergebnis zustande kommt; interessant ist lediglich das Ergebnis selbst. Auch ist es wünschenswert, bestimmte Bearbeitungsfolgen immer wieder verwenden zu können. Mit Hilfe von Funktionen ist die Zerlegung großer Problemstellungen in kleinere, d.h. die Modularisierung und Vereinfachung von Programmen möglich. In der Bartels User Language wird unterschieden zwischen den Systemfunktionen und den durch den Anwender definierten Funktionen.

Funktionsdefinition

Die Definitionen der Systemfunktionen sind dem Compiler bekannt, die Funktionen selbst sind in den Interpreter eingebunden. Anhang C enthält die Beschreibung dieser Systemfunktionen. Der Anwender kann also bei der Implementierung seiner Programme die Systemfunktionen verwenden und hat darüber hinaus die Möglichkeit, eigene Funktionen zu definieren.

Eine Funktionsdefinition besteht aus dem Funktionskopf (Header) und dem Funktionsrumpf (Block). Der Header enthält eine Typspezifikation und den Namen der Funktion, sowie die Definition und Deklaration der Funktionsparameter. Die Typspezifikation definiert den Datentyp des Wertes, den die Funktion an den Aufrufer zurückliefert (Rückgabewert). Hierbei steht zusätzlich der Datentyp void zur Verfügung, der dem Compiler angibt, dass die Funktion keinen Rückgabewert liefert. Wird die Datentypspezifikation weggelassen, dann wird der Funktion automatisch der Datentyp int zugeordnet. Nach dem Funktionsnamen folgt die Parameterdefinition. Diese besteht aus einer in runde Klammern eingeschlossenen Liste von durch Kommata getrennten Parameternamen bzw. Parameterdeklarationen. Für den Fall, dass die Funktion gar keine Parameter enthält, ist lediglich das Klammernpaar anzugeben. Alle definierten Parameter (außer den bereits in der Liste der Parameterdefinitionen deklarierten sowie den int-Typen) müssen nach der Liste der Parameterdefinitionen explizit vereinbart werden. Diese Parameterdeklarationen sind wie Variablendeklarationen vorzunehmen. Nach dem Funktionskopf muss der Funktionsrumpf definiert werden. Dieser ist ein durch geschweifte Klammern umschlossener Block von Anweisungen.

Beispiele für Funktionsdefinitionen:

double netroutwidth(index L_CNET net)
// Get the routing width of a given net
// Returns : width or 0.0 if two pins with different width
{
      index L_CPIN pin;       // Pin index
      int pincnt=0;           // Pin count
      double rw=0.0;          // Rout width
      // Loop thru all pins
      forall (pin of net) {
              // Test if the pin introduces a new rout width
              if (pin.RWIDTH!=rw && pincnt++>0)
                      return(0.0);
              // Set the rout width
              rw=pin.RWIDTH;
              }
      // Return the rout width
      return(rw);
}

int allpartsplaced()
// Test if all netlist-defined parts are placed
// Returns : 1 if all parts are placed or zero otherwise
{
      index L_CPART cpart;    // Connection part index
      // Loop thru the connection part list
      forall (cpart where !cpart.USED)
              // Unplaced part matched
              return(0);
      // All parts are placed
      return(1);
}

double getdistance(xs,ys,xe,ye)
// Get the distance between two points
// Returns : the distance length value
double xs, ys;                // Start point coordinate
double xe, ye;                // End point coordinate
{
      double xd=xe-xs;        // X distance
      double yd=ye-ys;        // Y distance
      // Calculate and return the distance (Pythagoras)
      return(sqrt(xd*xd+yd*yd));
}

double arclength(r,a1,a2)
// Get arc segment length by radius and start-/end-point angle
// Returns : the arc segment length value
double r;                     // Radius
double a1;                    // Start point angle (in radians)
double a2;                    // End point angle (in radians)
{
      // Arc; "absolute" angle between start and end point
      double arc = a1<a2 ? a2-a1 : 2*PI()+a2-a1;
      // Get and return the arc segment length
      return(arc*r);
}

double getangle(cx,cy,x,y)
// Get the angle of a circle arc point
// Returns : the angle (in radians; range [0,2*PI])
double cx, cy;                // Circle center coordinate
double x, y;                  // Circle arc point coordinate
{
      double res;             // Result value
      // Get arc tangent of angle defined by circle point
      res=atan2(y-cy,x-cx);
      // Test the result
      if (res<0.0)
              // Get the "absolute" angle value
              res=PI()-res;
      // Return the result value
      return(res);
}

double PI()
// Returns the value of PI in radians
{
      // Convert 180 degree and return the result
      return(cvtangle(180.0,1,2));
}

void cputimeuse(rn,st)
// Report CPU time usage (in seconds)
string rn;                    // Routine name
double st;                    // Start time
{
      // Print CPU time elapsed since start time
      printf("(%s) Elapsed CPU Time = %6.1f [Sec]\n",rn,clock()-st);
}

Funktionsaufruf und Wertübergabe

Jede in einem User Language-Programm (bzw. Programmtext) per Definition bekannte Funktion kann innerhalb dieses Programmes (bzw. in dem entsprechenden Programm-Modul) auch aufgerufen werden. Bei der Verwendung von User Language Systemfunktionen besteht jedoch die Einschränkung, dass in einem Programm nur zueinander kompatible Systemfunktionen verwendet werden können. Dies beruht auf der Tatsache, dass über derartige Funktionsaufrufe ggf. Aktionen ausgelöst werden, die nur in einer bestimmten Interpreterumgebung ausgeführt werden können (die Funktion zur Festlegung von Plotparametern im CAM-Prozessor des AutoEngineers kann selbstverständlich nicht im Schaltplaneditor aufgerufen werden). Bei der Verwendung zueinander nicht kompatibler Systemfunktionen gibt der User Language Compiler eine Fehlermeldung aus und erzeugt keinen Programm-Code. Ähnlich verhält sich der User Language Interpreter; beim Versuch ein User Language-Programm aufzurufen, das zur Interpreterumgebung inkompatible Systemfunktions-Referenzen enthält, erzeugt das System eine entsprechende Fehlermeldung und führt das betreffende Programm nicht aus. Die Information über die Kompatibilität der User Language-Systemfunktionen ist dem Anhang A bzw. dem Anhang C zu entnehmen.

Der Funktionsaufruf setzt sich zusammen aus dem Funktionsnamen und der in runden Klammern eingeschlossenen Liste der aktuellen Parameter, die der Funktion übergeben werden soll.

Die Inhalte der global definierten Variablen eines Programms stehen grundsätzlich in jeder Funktion desselben Geltungsbereichs zur Verfügung, d.h. globale Variablen können zur Übergabe von Werten an Funktionen benutzt werden. Darüber hinaus besteht die Möglichkeit der Wertübergabe über Funktionsparameter. Die Übergabe per Parameter kann einfach kontrolliert werden und ist daher i.d.R. der Methode der Übergabe über globale Variablen vorzuziehen. Die Liste der aktuellen Parameter, also der Ausdrücke, die man bei einem Funktionsaufruf übergibt, muss mit der formalen Parameterdefinition (also Anzahl und Datentypen) der aufzurufenden Funktion übereinstimmen. Beim Funktionsaufruf werden die Werte der aktuellen Parameter in die entsprechenden formalen Parameter kopiert. Nach erfolgreicher Beendigung der Funktion wird jeder durch die Funktion geänderte Parameterwert wieder auf den aktuellen Parameter zurückgespeichert, sofern dieser eine Variablenreferenz darstellt. Schließlich besteht noch die Möglichkeit der Wertübergabe über den Rückgabewert der Funktion. Dabei wird innerhalb der Funktion mit Hilfe der return-Anweisung ein Funktionsergebnis gesetzt, das anschließend vom Aufrufer innerhalb des Ausdrucks, der den Funktionsaufruf enthält, ausgewertet werden kann.

Beispiel für Funktionsaufruf und Wertübergabe:

// Date structure
struct date { int day, month, year; };
// Global program variables
string globalstr="Global string";
int fctcallcount=0;

// Main program
main()
{
      // Local variables of main
      string resultstr="function not yet called";
      struct date today = { 0, 0, 0 };
      double p=0.0, b=2.0, e=10.0;
      // Print the global variables
      printf("fctcallcount=%d, %s\n",fctcallcount,globalstr);
      // Print the local variables
      printf("resultstr=\"%s\"\n",resultstr);
      printf("today : %d,%d,%d",today.day,today.month,today.year);
      printf("\t\tb=%.1f, e=%.1f, p=%.1f\n",b,e,p);
      // Call function
      resultstr=function(today,b,e,p);
      // Print the global variables
      printf("fctcallcount=%d, %s\n",fctcallcount,globalstr);
      // Print the local variables
      printf("resultstr=\"%s\"\n",resultstr);
      printf("today : %d,%d,%d",today.day,today.month,today.year);
      printf("\t\tb=%.1f, e=%.1f, p=%.1f\n",b,e,p);
}

string function(curdate,base,exponent,power)
struct date curdate;          // Current date parameter
double base;                  // Base parameter
double exponent;              // Exponent parameter
double power;                 // Power parameter
{
      // Increment the function call count
      fctcallcount++;
      // Set the global string
      globalstr="Global string changed by function";
      // Get the current date
      get_date(curdate.day,curdate.month,curdate.year);
      // Calculate the power
      power=pow(base,exponent);
      // Return with a result string
      return("function result string");
}

Obiges Beispiel-Programm erzeugt folgende Ausgabe:

fctcallcount=0, Global string
resultstr="function not yet called"
today : 0,0,0         b=2.0, e=10.0, p=0.0
fctcallcount=1, Global string changed by function
resultstr="function result string"
today : 4,6,92                b=2.0, e=10.0, p=1024.0

Kontrollfluss und Programmstruktur

Jede Funktion der User Language behält nach ihrem Aufruf solange die Kontrolle, bis sie auf einen weiteren Funktionsaufruf, auf eine return-Anweisung, oder nach der Abarbeitung der letzten Anweisung der Funktion auf das Funktionsende trifft. Bei einem Funktionsaufruf wird die Kontrolle an die aufgerufene Funktion weitergegeben. Beim Erreichen einer return-Anweisung oder am Funktionsende wird die Kontrolle an den Aufrufer der Funktion zurückgegeben. Ist in einem Programm eine Anwenderfunktion mit dem Namen main definiert, dann erzeugt der User Language Compiler Programm-Code, der dafür sorgt, dass - unmittelbar nach der Initialisierung der globalen Variablen - diese Funktion aufgerufen wird. Der Kontrollfluss eines User Language-Programms beginnt also üblicherweise bei der Funktion main. Da bei rekursionsfreier Programmierung jede Funktion irgendwann ihre Kontrolle wieder an den Aufrufer zurückgibt, fällt die Kontrolle schließlich wieder an die main-Funktion. Wird darin dann das Funktionsende oder eine return-Anweisung erreicht, dann ist auch das Programmende erreicht, und der User Language Interpreter kann den Kontrollfluss beenden.

Rekursive Funktionen

Funktionen dürfen rekursiv benutzt werden, d.h. eine Funktion darf sich direkt oder indirekt selbst aufrufen. Dies ist jedoch nur dann sinnvoll, wenn sich bei jedem Aufruf ein Zustand derart verändert, dass sich irgendwann ein eindeutig definierter Endzustand einstellt, mit dessen Hilfe sich die Rekursion abbrechen lässt.

Durch die rekursive Programmierung von Funktionen kann man im Allgemeinen Programm-Code einsparen und eventuell die Lesbarkeit erhöhen. Die Programmlaufzeit und der Speicherplatzbedarf hingegen werden sich durch Rekursionen erhöhen. Daher sollte man jeweils prüfen, ob die Verwendung einer Rekursion tatsächlich nützlich ist. Auch besteht die Gefahr, dass man "versehentlich" eine Endlosrekursion implementiert, d.h. eine Rekursion, die nie den Endzustand erreicht. Der User Language Interpreter wird bei der Abarbeitung einer solchen Endlosrekursion irgendwann einen Speicher- bzw. Stapel-Überlauf feststellen, da für jeden Funktionsaufruf zumindest eine Rücksprung-Adresse gespeichert werden muss.

2.3.4 Regeln zum Geltungsbereich

Bei der Referenzierung der Objekte eines User Language-Programms muss der Compiler jeweils die Gültigkeit der Referenz überprüfen. Hierzu ist jedem Objekt ein bestimmter Geltungsbereich innerhalb des Programms zugeordnet. Innerhalb dieses Geltungsbereiches ist das entsprechende Objekt bekannt und kann referenziert werden. Es wird unterschieden zwischen globalem und lokalem Geltungsbereich. Der globale Geltungsbereich erstreckt sich über das gesamte Programm (also auch auf noch einzubindende, getrennt kompilierte Programmteile bzw. Libraries), während die lokalen Geltungsbereiche des Programms Bezug nehmen auf die Funktionsdefinitionen.

Die Funktionen eines Programms sind global, d.h. im gesamten Programm gültig. Variablen- und Typ-Definitionen, die in einer Funktion vorgenommen werden, gelten nur lokal innerhalb dieser Funktion; außerhalb von Funktionen gelten derartige Definitionen als global. Die Parameterdefinitionen einer Funktione werden wie lokale Variablen behandelt und gelten daher immer nur lokal innerhalb der betreffenden Funktion. Strukturdefinitionen gelten allgemein als global im aktuell zu übersetzenden Programmtext. Durch die Zuweisung der Speicherklasse static kann der Geltungsbereich von Funktionen und globalen Variablen eingeschränkt werden auf den aktuell zu übersetzenden Programmtext. Die Speicherklasse static dient insbesondere der Vermeidung von Namenskonflikten beim Binden bzw. Linken unterschiedlicher Programm-Module bzw. Libraries.

Um Namenskonflikte zu vermeiden, müssen die Elemente jeder Objektklasse innerhalb ihres Geltungsbereichs jeweils unterschiedliche Namen besitzen. Bei der Referenzierung haben die lokalen Objekte Vorrang vor den globalen.

2.4 Ausdrücke

In diesem Abschnitt werden die in der User Language verfügbaren Operatoren für Ausdrücke vorgestellt. Die Reihenfolge, in der dabei vorgegangen wird, entspricht dem abnehmenden Vorrang der Operatoren, wobei jeweils auch auf die Assoziativität d.h. die Verarbeitungsfolge der jeweiligen Operation eingegangen wird. Jeder Operator ist entweder links- oder rechts-assoziativ, je nachdem ob er von links oder rechts implizit geklammert wird. Der Vorrang gibt an, mit welcher Priorität ein Ausdruck bewertet wird. Abgesehen vom Vorrang ist die Reihenfolge der Bewertung undefiniert. Es ist der Implementierung freigestellt, Teilausdrücke auch dann, wenn diese Nebeneffekte verursachen, in möglichst effizienter Reihenfolge zu bewerten. Die Reihenfolge für die Evaluierung von Nebeneffekten ist dabei nicht definiert. Ausdrücke mit assoziativen und kommutativen Operatoren lassen sich beliebig umordnen. Eine bestimmte Reihenfolge in der Bewertung von Operanden kann nur durch Zuweisung an (temporäre) Variablen erzwungen werden.

2.4.1 Primäre Ausdrücke

Primäre Ausdrücke, auch bezeichnet als einfache Ausdrücke oder Primary, sind Konstanten, Verweise auf Objekte, Ausdrucks-Klammerungen, Funktionsaufrufe, sowie die Auswahl von Elementen aus einem Vektor, einer Struktur oder einem Index. Diese Operationen sind links-assoziativ.

Konstanten und Verweise auf Objekte

Jeder geeignet vereinbarte Identifier gilt als primärer Ausdruck, der auf ein Objekt verweist. Auch ganzzahlige, Gleitkomma-, Zeichen- und String-Konstanten sind primäre Ausdrücke; die Darstellungsformen für Konstanten wurden in Kapitel 2.2.3 vorgestellt.

Ausdrucks-Klammerung

Ein geklammerter Ausdruck besteht aus einem in runde Klammern eingeschlossenen Ausdruck und stellt einen primären Ausdruck dar. Mit Hilfe dieses Operators können Ausdrücke explizit geklammert werden, wodurch eine definierte Änderung der Reihenfolge der Bewertung herbeigeführt werden kann. Da der Multiplikations-Operator z.B. höheren Vorrang hat als der Additions-Operator, ergibt sich der Wert des Ausdrucks

a + b * c

aus der Summe aus a und dem Produkt b*c, während er sich in

(a + b) * c

aus dem Produkt aus der Summe a+b und c ergibt.

Funktionsaufruf

Ein Funktionsaufruf besteht aus einem Identifier zur Bezeichnung der aufzurufenden Funktion gefolgt von einer in runde Klammern eingeschlossenen Liste von Ausdrücken, die durch Kommata getrennt sind. Die Werte der Ausdrücke innerhalb der runden Klammern repräsentieren die aktuellen Parameter für den Funktionsaufruf. Sofern eine Funktion per Definition einen Resultatwert liefert, kann der entsprechende Funktionsaufruf in einem beliebigen anderen Ausdruck verwendet werden. Die Liste der Ausdrücke innerhalb der runden Klammern kann leer sein. Typische Funktionsaufrufe sind z.B.

init_states(pass=1);
printf("This is a message!\n");
printf("Element %s\n",bae_planename());
xpos=nref_xcoord(ask_partname())-bae_planwsnx();

Zugriff auf Vektor-Element

Ein einfacher Ausdruck gefolgt von einem Ausdruck in eckigen Klammern ist wiederum ein einfacher Ausdruck. Mit dieser Operation erfolgt die Auswahl eines Elements aus einem Vektor oder string-Wert. Der Ausdruck vor der eckigen Klammer referenziert dabei den Vektor, der Ausdruck innerhalb der eckigen Klammern wird als int-Wert interpretiert und dient der Indizierung des Vektor-Elements. Der Indizierungs-Wert darf dabei nicht negativ sein; der Wert 0 (Null) verweist auf das erste Element des Vektors. Beim Speichern auf einen Vektor erfolgt ggf. eine dynamische Anpassung des Vektor-Feldbereichs durch den User Language Interpreter. Der lesende Zugriff auf einen Vektor ist nur innerhalb des aktuell definierten Feldbereiches zulässig. Die folgende Funktion strisoctal überprüft, ob der als Parameter übergebene string-Wert nur oktale Ziffern (0 bis 7) enthält und gibt für diesen Fall den Wert 1, in allen anderen Fällen den Wert 0 zurück:

int strisoctal(string str)
{
      for (i=0;i<strlen(str);i++)
              if (!isdigit(str[i]) || str[i]=='8' || str[i]=='9')
                      return(0);
      return(1);
}

In obigem Beispiel wird die Feldlängen-Kontrolle für den Vektor-Lese-Zugriff mit Hilfe der auf string-Werte anwendbaren Systemfunktion strlen durchgeführt. Im folgenden Programm-Konstrukt hingegen geschieht dies mit Hilfe einer speziellen int-Variablen (filecount):

string curfilename="", filelist[];
int i, filecount=0;
while (scandirfnames(".",".ddb",curfilename)==1)
      filelist[filecount++]=curfilename;
for (i=0;i<filecount;i++)
      printf("File %s \n",filelist[i]);

In obigem Beispiel wird zunächst eine Liste aller im aktuellen Verzeichnis auffindbaren Dateinamen mit der Endung .ddb erzeugt, und anschließend wird diese Liste ausgegeben.

Zugriff auf Struktur- oder Index-Element

Ein einfacher Ausdruck gefolgt von einem Punkt und einem Identifier ist wieder ein einfacher Ausdruck. Der erste Ausdruck referenziert dabei eine Struktur bzw. einen Index-Typ, und der Identifier nach dem Punkt-Operator muss ein definiertes Element aus dieser Struktur bzw. diesem Index-Typ bezeichnen. Der schreibende Zugriff auf Struktur-Elemente ist grundsätzlich immer möglich; auf die Elemente von Index-Typen hingegen darf nicht gespeichert werden (Fehlermeldung durch den Compiler). Umgekehrt ist der lesende Zugriff auf die Elemente einer aktuell gültigen index-Variablen immer zulässig, während aus struct-Variablen nur die zuvor initialisierten gelesen werden können (ansonsten Speicherzugriffs-Verletzung und entsprechende Fehlermeldung durch den Interpreter). Der folgende Programmteil definiert eine Liste bestehend aus Strukturen und erzeugt für jedes aktuell verfügbare Layout-Macro einen Listen-Eintrag mit dem Macro-Namen und der Macro-Klasse:

int macrocnt=0;
struct { string name; int class; } macrolist[];
index L_MACRO macro;
forall (macro) {
      macrolist[macrocnt].name=macro.NAME;
      macrolist[macrocnt++].class=macro.CLASS;
      }

2.4.2 Unitäre Ausdrücke

Unitäre Ausdrücke, auch bezeichnet als Unary, sind rechts-assoziativ und umfassen alle Operatoren, die einen einzelnen Operanden bewerten.

Inkrement und Dekrement

Die Operatoren ++ bzw. -- verändern ihre Operanden, indem sie den Wert 1 zum Wert ihres Operanden addieren bzw. subtrahieren. Sind diese Operatoren einem unitären Ausdruck vorangestellt, dann entspricht das Resultat dem Wert des Operanden nach dessen Inkrementierung bzw. Dekrementierung. Im anderen Fall, also wenn ++ bzw. -- auf den Operanden folgt, dann wird zwar der Operand inkrementiert bzw. dekrementiert, das Resultat entspricht jedoch dem Wert des Operanden vor der Durchführung der Operation. Dies bedeutet, dass in einem Kontext, in dem der Resultatwert einer Inkrement- bzw. Dekrement-Operation weiter verwendet wird, die entsprechenden Ausdrücke unterschiedliche Bedeutung haben. Besitzt zum Beispiel die Variable count den Wert 12 dann erhält die Variable n durch die Zuweisung

n = count-- ;

den Wert 12, durch die Zuweisung

n = --count ;

jedoch den Wert 11 (der Wert von count ergibt sich in beiden Fällen zu 11).

Arithmetische Negation

Der unitäre Operator - liefert den Wert der arithmetischen Negation seines Operanden, das Resultat ist also der mit (-1) multiplizierte Wert des Operanden.

Logische Negation

Der unitäre Operator ! liefert den Wert der logischen Negation seines Operanden. Das Resultat ist dabei 1 für einen Operanden mit dem Null-Wert (0 oder Leerstring für string-Operand), und 0 für alle anderen Operanden-Werte.

Bit-Komplement

Der Operator ~ komplementiert die einzelnen Bits in seinem Operanden, liefert also als Ergebnis das 1-Komplement seines Operanden.

2.4.3 Binäre Ausdrücke

Binäre Ausdrücke, auch bezeichnet als Binary, umfassen alle Operatoren, die zwei Operanden bewerten.

Produkt

Die Operatoren für Multiplikation und Division sind links-assoziativ und erzeugen jeweils einen Produkt-Ausdruck. Der binäre Operator * ist kommutativ und assoziativ und bezeichnet die Multiplikation. Das Ergebnis dieser Operation ist der Wert des Produktes seiner beiden Operanden. Der binäre Operator / bezeichnet die Division. Das Ergebnis dieser Operation ist der Wert, der durch die Division des Wertes des ersten Operanden (Divident) geteilt durch den Wert des zweiten Operanden (Divisor) der Operation zustande kommt. Da eine Division durch Null nicht zulässig ist, ist der Wert 0 für den Divisor auch nicht erlaubt. Der binäre Operator % liefert den Rest nach Division seiner beiden Operanden. Gleitkomma-Operanden sind hierbei nicht zulässig; ebenso ist der Wert 0 für den Divisor nicht erlaubt; ein Beispiel für die Verwendung des %-Operators ist der Ausdruck

febdays = (year%4==0 && year%100!=0 || year%400==0) ? 29 : 28 ;

in dem zunächst überprüft wird, ob der Wert von year der Jahreszahl eines Schaltjahres entspricht, und anschließend in Abhängigkeit vom Ergebnis dieser Überprüfung der Wert der Variablen febdays gesetzt wird.

Summe

Die Operatoren für Addition und Subtraktion sind links-assoziativ und erzeugen jeweils einen Summen-Ausdruck. Der binäre Operator + bezeichnet die Addition. Für den Fall, dass dieser Operator auf numerische Werte angewendet wird, ist das Ergebnis dieser Operation die Summe der Operanden, und die Operation ist in diesem Fall assoziativ und kommutativ; wird diese Operation auf Zeichenketten angewendet, dann ergibt sich das Resultat zu dem string-Wert, der sich durch Aneinanderfügen der string-Werte der Operanden ergibt. Der binäre Operator - bezeichnet die Subtraktion und liefert als Ergebnis den Wert der Differenz seiner Operanden.

Schiebe-Operation

Die Schiebe-Operatoren << und >> sind links-assoziativ und können auf ganzzahlige Operanden angewendet werden. Der binäre Operator << bezeichnet die bitweise Links-Verschiebung. Das Ergebnis dieser Operation ist der Wert, der sich ergibt, wenn das Bitmuster des ersten Operanden um die Anzahl der durch den zweiten Operanden gegebenen Stellen nach links verschoben wird (von rechts her werden dabei Bits mit dem Wert 0 nachgeschoben; das Ergebnis ist undefiniert, wenn der zweite Operand negativ ist). Der binäre Operator >> bezeichnet die bitweise Rechts-Verschiebung. Das Ergebnis dieser Operation ist der Wert, der sich ergibt, wenn das Bitmuster des ersten Operanden um die Anzahl der durch den zweiten Operanden gegebenen Stellen nach rechts verschoben wird (das Ergebnis ist undefiniert, wenn der zweite Operand negativ ist).

Vergleich

Die binären Operatoren < (kleiner), <= (kleiner oder gleich), > (größer) und >= (größer oder gleich) liefern den int-Wert 0, wenn die angegebene Relation in Bezug auf die beiden Operanden falsch ist, und den Wert 1, wenn die Relation vorliegt. Diese Operatoren sind auch direkt auf string-Typen anwendbar.

Äquivalenz-Vergleich

Die binären Operatoren == (gleich) und != (ungleich) liefern den int-Wert 0, wenn die angegebene Äquivalenz-Relation in Bezug auf die beiden Operanden falsch ist, und den Wert 1, wenn die Relation vorliegt. Die Äquivalenz-Vergleichs-Operatoren sind auch direkt auf string-Typen anwendbar; sie verhalten sich analog zu den anderen Vergleichs-Operatoren, haben jedoch geringeren Vorrang.

Bitweise Und-Verknüpfung

Der binäre Operator & bezeichnet die bitweise Und-Verknüpfung (AND) und ist assoziativ und kommutativ. Das Resultat dieser Operation ist der Wert, der sich ergibt, wenn die Bits der beiden Operanden in jeder Position der Und-Verknüpfung unterworfen werden.

Bitweise Exklusiv-Oder-Verknüpfung

Der binäre Operator ^ bezeichnet die bitweise Exklusiv-Oder-Verknüpfung (XOR) und ist assoziativ und kommutativ. Das Resultat dieser Operation ist der Wert, der sich ergibt, wenn die Bits der beiden Operanden in jeder Position der Exklusiv-Oder-Verknüpfung unterworfen werden.

Bitweise Oder-Verknüpfung

Der binäre Operator | bezeichnet die bitweise Oder-Verknüpfung (OR) und ist assoziativ und kommutativ. Das Resultat dieser Operation ist der Wert, der sich ergibt, wenn die Bits der beiden Operanden in jeder Position der Oder-Verknüpfung unterworfen werden.

Logische Und-Verknüpfung

Der binäre Operator && bezeichnet die logische Und-Verknüpfung (AND) und ist links-assoziativ. Das Resultat dieser Operation ist der int-Wert 1, wenn die Werte beider Operanden vom Null-Wert (0 oder Leerstring für string-Operanden) verschieden sind; im anderen Fall ergibt sich das Resultat zum Wert 0. Die logische Und-Verknüpfung wird strikt von links nach rechts durchgeführt; der rechte Operand wird dabei nur bewertet, wenn der linke Operand kein Null-Wert ist. Im Ausdruck

x<100 && fct(x)

wird die Funktion fct nur dann aufgerufen, wenn der Wert von x kleiner als 100 ist.

Logische Oder-Verknüpfung

Der binäre Operator || bezeichnet die logische Oder-Verknüpfung (OR) und ist links-assoziativ. Das Resultat dieser Operation ist der int-Wert 1, wenn einer der beiden Operanden-Wert vom Null-Wert (0 oder Leerstring für string-Operanden) verschieden ist; im anderen Fall ergibt sich das Resultat zum Wert 0. Die logische Oder-Verknüpfung wird strikt von links nach rechts durchgeführt; der rechte Operand wird dabei nur bewertet, wenn der Wert des linken Operanden dem Null-Wert entspricht. Im Ausdruck

test1() || test2()

wird die Funktion test2 also nur dann aufgerufen, wenn zuvor der Aufruf der Funktion test1 das Resultat 0 geliefert hat.

Bedingte Bewertung

Der Operator ?: bezeichnet die bedingte Bewertung (conditional) und ist rechts-assoziativ. Vor dem ?:-Operator hat ein binärer Ausdruck zu stehen, der in jedem Fall bewertet wird. Ist der Wert dieses Ausdrucks vom Null-Wert (0 oder Leerstring für string) verschieden, dann ergibt sich das Resultat dieser Operation zum Wert des zweiten Ausdrucks (dieser befindet sich zwischen dem Fragezeichen und dem Doppelpunkt des Operators und kann wiederum eine bedingte Bewertung sein); im anderen Fall, also wenn der erste Operand dem Null-Wert entspricht, dann ergibt sich das Resultat zum Wert des dritten Ausdrucks (dieser folgt auf den Doppelpunkt Fragezeichen des Operators und kann ebenfalls eine bedingte Bewertung sein). Der allgemeine Ausdruck

result = logexpr ? trueexpr : falsexpr ;

für die Zuweisung einer bedingte Bewertung an ein Resultat entspricht also der folgenden Kontrollstruktur:

if (logexpr)
      result = trueexpr ;
else
      result = falseexpr ;

Beispiel für die Verwendung des ?:-Operators zur Berechnung des Maximums zweier Werte:

maxval = (val1>=val2) ? val1 : val2 ;

Zuweisungen

Der binäre Operator = bezeichnet die einfache Zuweisung, die binären Operatoren *=, /=, %=, +=, -=, >>=, <<=, &=, ^= und |= bezeichnen die zusammengesetzten Zuweisungen. Alle diese Operatoren sind rechts-assoziativ. Der linke Operand muss immer ein unitärer Ausdruck sein, der rechte Operand darf seinerseits ein Zuweisungs-Ausdruck sein. Bei der einfachen Zuweisung ersetzt der Wert des rechten Operanden den Wert des durch den linken Operanden referenzierten Objekts. Eine zusammengesetzte Zuweisung der allgemeinen Form

expr1 <operator>= expr2

entspricht dem Ausdruck

expr1 = expr1 <operator> (expr2)

wobei jedoch expr1 nur einmal bewertet wird (man beachte die Klammerung des Ausdrucks expr2). In der Zuweisungsfolge

a = 5 ;
b = 3-a ;
c = b+a ;
c -= a *= b += 4+2*a ;

ergeben sich die Werte der Variablen a, b und c zu 60, 12 und -57.

2.4.4 Liste von Ausdrücken

Jeder Ausdruck kann aus einer Liste von durch Kommata getrennten binären Ausdrücken bestehen. Zwei Ausdrücke, die durch Komma getrennt sind, werden dabei von links nach rechts bewertet; der Wert des linken Ausdrucks wird berechnet, aber nicht weiter verwendet. Typ und Wert des Resultats einer Liste von Ausdrücken entsprechen dem Typ und Wert des rechten Ausdrucks innerhalb der Ausdruck-Liste. Diese Operation ist links-assoziativ. In einem Kontext, in dem das Komma eine spezielle Bedeutung hat, wie etwa in der Liste von Argumenten für einen Funktionsaufruf, oder in einer Liste von Initialisierungen, kann der hier beschriebene Komma-Operator nur innerhalb von Klammern verwendet werden. Durch die Zuweisung

c -= (a=5, b=3-a, c=b+a, a*=b+=4+2*a) ;

ergeben sich die Werte der Variablen a, b und c zu 60, 12 und -57.

2.4.5 Vorrang und Reihenfolge der Bewertung

In Tabelle 2-4 sind nochmals der Vorrang und die Assoziativität der Operatoren der Bartels User Language zusammengefasst dargestellt.

Tabelle 2-4: Operator Vorrang und Assoziativität

2.5 Kontrollstrukturen

In diesem Abschnitt werden die in der User Language verfügbaren Kontrollstrukturen vorgestellt. Kontrollstrukturen definieren die Reihenfolge, in der die Aktionen eines Programms ausgeführt werden. Grundsätzlich wird in der Bartels User Language - entsprechend den Grundlagen der strukturierten Programmierung - unterschieden zwischen sequentiellen Programm-Elementen, Alternativen und Repetitionen (englisch: CAR - Concatenation, Alternation, Repetition).

2.5.1 Sequentielle Programm-Elemente

Anweisungen

Eine Anweisung besteht aus einem Ausdruck (siehe Kapitel 2.4) gefolgt von einem Semikolon (;). Somit sind z.B.

tabulator = '\t' ;
distance = sqrt(a*a+b*b) ;
filename += extension = ".ddb" ;
++ary[i] ;
printf("Part %s ;\n",partname) ;

gültige Anweisungen. Fehlt der Ausdruck vor dem Semikolon, hat die Anweisung also die Form

;

dann liegt liegt der Sonderfall der leeren Anweisung vor. Die leere Anweisung kann in Ausnahmefällen dazu dienen, abhängige Anweisungen (z.B. innerhalb von Schleifen) zu definieren. Grundsätzlich sind sonst aber nur solche Anweisungen sinnvoll, die auch einen Seiteneffekt haben, d.h. irgendeine Variable durch eine Zuweisung verändern oder eine Funktion aktivieren. In der User Language sind allerdings auch Anweisungen zulässig, die keine Seiteneffekte haben wie z.B.

27+16.3;
++11;

Der User Language Compiler erkennt Ausdrücke ohne Seiteneffekte und gibt ggf. entsprechende Warnungen aus.

Anweisungen, die in einer Kontext-Abhängigkeit zu einer Alternative bzw. Repetition (siehe unten) stehen, werden im Folgenden als abhängige Anweisungen bezeichnet.

Blöcke

Ein Block besteht aus einer Folge von Vereinbarungen (siehe Kapitel 2.3.2) und Anweisungen und ist in geschweifte Klammern ({ und }) einzuschließen. Ein Block ist syntaktisch äquivalent zur einfachen Anweisung, kann also auch immer anstelle einer einfachen Anweisung angegeben werden.

2.5.2 Alternativen

Alternativen sind Verzweigungen, die die Ausführung bestimmter abhängiger Anweisungen vom Wert eines Ausdrucks abhängig machen.

if- und if-else-Anweisung

Die if-Anweisung hat die allgemeine Form

if (expression)
      statement

Die abhängige Anweisung der if-Anweisung wird nur ausgeführt, wenn der if-Ausdruck einen vom Nullwert (0 bzw. Leerstring für string-Ausdruck) verschiedenen Wert besitzt; andernfalls wird sie übersprungen.

Die if-else-Anweisung besitzt die allgemeine Form

if (expression)
      statement
else
      statement

Zunächst wird der Ausdruck der if-else-Anweisung bewertet. Ist dabei das Resultat vom Null-Wert (0 bzw. Leerstring beim string-Ausdruck) verschieden, wird die erste abhängige Anweisung ausgeführt. Die zweite abhängige Anweisung wird genau dann ausgeführt, wenn das Resultat des Ausdrucks dem Null-Wert entspricht. Die abhängigen Anweisungen der if-else-Anweisung können selbstverständlich wiederum if-else-Anweisungen sein. Damit können auch Verschachtelungen und Ketten von if-else-Anweisungen der Form

if (expression)
      statement
else if (expression) {
      if (expression)
              statement
      }
else if (expression)
      statement
:
else
      statement

gebildet werden. Bei verschachtelten if-else-Anweisungen gehört die else-Anweisung immer zum nächstfrüheren if, für das noch kein else-Teil existiert. In folgendem Beispiel wird die Klasse des aktuell geladenen SCM-Elements abgefragt, und der Wert der Variablen classname wird entsprechend gesetzt:

string classname="SCM ";
if (bae_planddbclass()==800)
      classname+="Sheet";
else if (bae_planddbclass()==801 || bae_planddbclass()==803)
      classname+="Symbol/Label";
else if (bae_planddbclass()==802)
      classname+="Marker";
else {
      classname="***INVALID***";
      printf("No valid element loaded!\n");
      }

switch Anweisung

Die switch-Anweisung sorgt dafür, dass in Abhängigkeit vom Wert eines auf Gleichheit prüfenden Äquivalenz-Ausdrucks bestimmte Anweisungen ausgeführt werden und andere nicht. Die allgemeine Form der switch-Anweisung ist gegeben durch

switch (expression)
      statement

Jeder Anweisung innerhalb der abhängigen switch-Anweisung kann eine beliebige Anzahl von case-Marken der Form

case expression :

oder

default :

vorausgehen. Die zwischen case-Marken befindlichen Anweisungen stehen in Abhängigkeit zu den unmittelbar vorhergehenden case-Marken. Die abhängigen Anweisungen einer case-Marke werden nur dann ausgeführt, wenn der Wert des switch-Ausdrucks mit dem Wert des case-Ausdrucks übereinstimmt; die default-Marke spezifiziert dabei einen beliebigen Wert, d.h. die einer default-Marke folgenden abhängigen Anweisungen kommen immer zur Ausführung. case-Marken selbst haben keinen Einfluss auf die sequentielle Ausführung einer Reihe von Anweisungen; die Ausführung wird fortgesetzt, als ob keine case-Marken vorhanden sind. Um eine switch-Anweisung zu verlassen wird üblicherweise in einem case-Abschnitt die break-Anweisung (siehe auch Kapitel 2.5.4) benutzt. In folgendem Beispiel wird die Klasse des aktuell geladenen SCM-Elements abgefragt, und der Wert der Variablen classname wird entsprechend gesetzt:

string classname="SCM ";
switch (bae_planddbclass()) {
      case 800 :
      classname+="Sheet";
      break;
      case 801 :
      case 803 :
      classname+="Symbol/Label";
      break;
      case 802 :
      classname+="Marker";
      break;
      default :
      classname="***INVALID***";
      printf("No valid element loaded!\n");
      }

2.5.3 Repetitionen

Repetitionen sind Anweisungen, mit deren Hilfe Schleifen zur wiederholten, also repetitiven Abarbeitung bestimmter Teile des Programms definiert werden können. Jede repetitive Anweisung verfügt auch über einen Mechanismus zur Überprüfung einer Ende-Bedingung, bei der die Schleifen-Bearbeitung beendet wird. Wird diese Ende-Bedingung nie erreicht, dann spricht man von einer Endlos-Schleife. Läuft ein Programm während der Abarbeitung in eine derartige Endlos-Schleife, dann kann es den Kontrollfluss nicht mehr von sich aus an den Aufrufer zurückgeben. In solchen Fällen liegt in der Regel ein schwerer Programmierfehler vor. Erkennt der User Language Compiler eine Endlos-Schleife, wozu er in bestimmten Fällen in der Lage ist, dann gibt er eine entsprechende Fehlermeldung aus und erzeugt keinen Programm-Code.

while-Anweisung

Die while-Anweisung hat die allgemeine Form

while (expression)
      statement

Die abhängige Anweisung wird solange wiederholt, wie der Wert des while-Ausdrucks ungleich dem Nullwert (0 oder Leerstring für string-Ausdruck) ist. Das folgende Programm dient dazu, die Inhalte von ASCII-Dateien auf dem Bildschirm anzuzeigen:

// ASCII file view
main()
{
      string fname;           // File name
      int fh;                 // File handle
      string curstr="";       // Current input string
      // Set the file error handle mode
      fseterrmode(0);
      // Print the program banner
      printf("ASCII FILE VIEWER STARTED\n");
      // Repeatedly ask for the input file name
      while (fname=askstr("File Name (press RETURN to exit) : ",40)) {
              // Open the input file
              printf("\n");
              if ((fh=fopen(fname,0))==(-1)) {
                      printf("File open failure!\n");
                      continue;
                      }
              // Get the current input string
              while (fgets(curstr,128,fh)==0)
                      // Print the current input string
                      puts(curstr);
              // Test on read errors; close the file
              if (!feof(fh) || fclose(fh))
                      // Read or close error
                      break;
              }
}

Die continue-Anweisung (siehe auch Kapitel 2.5.4) wird in obigem Beispiel verwendet, um wieder an den Beginn der while-Anweisung zu springen; die break-Anweisungen (siehe auch Kapitel 2.5.4) dienen dazu, im Fehlerfall die while-Anweisung zu verlassen.

do-while-Anweisung

Die do-while-Anweisung hat die allgemeine Form

do
      statement
while (expression);

Die abhängige Anweisung wird solange wiederholt, bis der Wert des do-while-Ausdrucks gleich dem Nullwert (0 oder Leerstring für string-Ausdruck) ist. Die abhängige Anweisung wird also im Unterschied zur while-Anweisung mindestens einmal ausgeführt.

for-Anweisung

Die for-Anweisung hat die allgemeine Form

for (expression1; expression2; expression3)
      statement

und ist äquivalent zu

experession1;
while (expression2) {
      statement;
      expression3;
      }

Zunächst wird der erste Ausdruck bewertet. Anschließend werden, solange der zweite Ausdruck nicht gleich dem Nullwert (0 bzw. Leerstring für string-Ausdruck) ist, die abhängige Anweisung ausgeführt und der dritte Ausdruck bewertet. Der erste for-Ausdruck dient also der Initialisierung, der zweite der Schleifenende-Prüfung, und der dritte typischerweise einer Inkrementierung. Jeder einzelne der drei for-Ausdrücke darf auch fehlen. Die folgende Funktion strwords zerlegt einen als Parameter übergebenen string-Wert in seine einzelnen (durch Blank oder Tabulator) getrennten Worte, speichert diese in einer Liste ab und gibt sie anschließend in umgekehrter Reihenfolge aus:

void strwords(string s)
{
      string strlist[];
      int strcount,i,j;
      char c;
      for ( strcount=0,j=0,i=0 ; c=s[i++] ; ) {
              if (c==' ' || c=='\t') {
                      if (j>0) {
                              strcount++;
                              j=0;
                              }
                      continue;
                      }
              strlist[strcount][j++]=c;
              }
      for ( i=strcount ; i>=0 ; i-- )
              printf("%s\n",strlist[i]);
}

forall-Anweisung

Die forall-Anweisung hat die allgemeine Form

forall (identifier1 of identifier2 where expression)
      statement

Die forall-Anweisung dient der automatischen sequentiellen Abarbeitung der aktuell verfügbaren Elemente eines index-Datentyps. Der erste Identifier muss eine index-Variable referenzieren, über die der Typ des abzuarbeitenden forall-Index spezifiziert wird. Die forall-Anweisung sorgt selbsttätig für die Initialisierung und Inkrementierung dieser Variablen. Ist keine Inkrementierung mehr möglich, weil das letzte Element der index-Liste erreicht ist, dann ist automatisch auch das Ende-Kriterium erreicht und die Programmausführung wird mit der Anweisung, die der forall-Anweisung folgt, fortgesetzt. Die of-Anweisung innerhalb der forall-Anweisung dient der Spezifikation eines dem forall-Index hierarchisch übergeordneten index-Wertes, d.h. der zweite Identifier muss eine index-Variable referenzieren, innerhalb der die Abarbeitung des forall-Index per Definition zulässig ist. Der where-Ausdruck schließlich dient dazu, zu entscheiden, ob die abhängige Anweisung für den aktuellen forall-Index ausgeführt werden soll (Wert des Ausdrucks ungleich dem Nullwert) oder nicht (Wert des Ausdrucks gleich dem Nullwert). Sowohl die of-Anweisung als auch die where-Anweisung können wahlweise weggelassen werden, so dass die kürzeste Form der forall-Anweisung gegeben ist durch

forall (identifier1)
      statement

Die index-Variablen-Typen sind in Anhang B beschrieben. Folgendes Beispiel gibt für alle platzierten Bauteile der aktuell geladenen physikalischen Netzliste eine Liste der Pins aus, die mit dem Netz vcc verbunden sind:

index L_CPART part;
index L_CPIN pin;
forall (part where part.USED) {
      forall (pin of part where pin.NET.NAME=="vcc")
              printf("Part %s, Pin %s ;\n",part.NAME,pin.NAME);

2.5.4 Kontrollfluss-Steuerung

Neben den bisher vorgestellten Kontrollstrukturen verfügt die User Language über einige spezielle Kontrollstrukturen, mit denen der Kontrollfluss zusätzlich gesteuert werden kann.

break-Anweisung

Die break-Anweisung hat die allgemeine Form

break;

Die break-Anweisung muss sich in der Abhängigkeit einer repetitiven (while, do-while, for oder forall) oder einer switch-Anweisung befinden (andernfalls Fehlermeldung durch den Compiler). Sie sorgt für den Abbruch der nächstgelegenen repetitiven bzw. switch-Anweisung, d.h. die Ausführung des Programms wird mit der Anweisung fortgesetzt, die der abgebrochenen Anweisung normalerweise folgt.

continue-Anweisung

Die continue-Anweisung hat die allgemeine Form

continue;

Die continue-Anweisung muss sich in der Abhängigkeit einer repetitiven (while, do-while, for oder forall) Anweisung befinden (andernfalls Fehlermeldung durch den Compiler). Sie sorgt dafür, dass die Ausführung des Programms an der Stelle fortgesetzt wird, an der über die Wiederholung der nächstgelegenen repetitiven Anweisung entschieden wird.

Funktionsaufruf und return-Anweisung

Sowohl der Funktionsaufruf als auch die return-Anweisung wurden bereits vorgestellt. Sie seien an dieser Stelle jedoch nochmals aufgeführt, um zu verdeutlichen, dass auch sie den Kontrollfluss entscheidend beeinflussen.

Der Funktionsaufruf ist ein Ausdruck, der einen Sprung zur ersten Anweisung der entsprechenden Funktionsdefinition bewirkt. Die return-Anweisung darf nur innerhalb von Funktionen verwendet werden. Sie sorgt dafür, dass die Ausführung des Programms unmittelbar nach dem Funktionsaufruf der den Sprung in die Funktion veranlasst hat, fortgesetzt wird, d.h. es erfolgt ein Abbruch der Funktionsausführung, und der Kontrollfluss wird wieder an den Aufrufer der Funktion zurückgegeben. Die allgemeine Form der return-Anweisung ist gegeben durch

return;

bzw.

return expression;

Enthält die return-Anweisung keinen Ausdruck, dann ist der Rückgabewert des Funktionsaufrufes undefiniert. Im anderen Fall ergibt sich der Rückgabewert der Funktion aus dem return-Ausdruck, der typ-kompatibel zu dem für die Funktion definierten Datentyp sein muss (ansonsten Fehlermeldung durch den Compiler). Trifft der User Language Compiler auf das Ende eines Funktionsblocks, dann erzeugt er, sofern die letzte Anweisung des Blocks nicht eindeutig als return-Anweisung erkannt werden kann, an dieser Stelle Programm-Code, der einer return-Anweisung (ggf. mit zum Funktionsdatentyp kompatiblem Null-Wert) entspricht. Die Erzeugung eines Nullwertes ist hierbei allerdings nicht für zusammengesetzte Datentypen möglich. D.h., Funktionsdefinitionen der Form

struct structname functionname() { }

provozieren eine Compiler-Fehlermeldung, da der User Language Interpreter beim lesenden Zugriff auf ein Element des Rückgabewertes einer solchen Funktion in jedem Fall eine Speicherzugriffs-Verletzung (Memory Protection Fault) feststellen würde.

2.6 Preprozessor-Anweisungen

Der Bartels User Language Compiler kann spezielle Preprozessor-Anweisungen zur Steuerung der Quelltextabarbeitung verarbeiten. Derartige Anweisungen beginnen mit dem Zeichen # und werden durch das Zeilenende begrenzt. Preprozessor-Anweisungen sind an beliebigen Stellen des Quelltextes zulässig; ihr Wirkungsbereich erstreckt sich bis zum Ende des jeweiligen Quelltextes.

2.6.1 Dateieinbindung

Im Sprachumfang der User Language ist die aus Standard C bekannte #include-Anweisung enthalten. Die #include-Anweisung dient dazu, Deklarationen und Funktionen, die in unterschiedlichen Programmen identisch verwendet werden und in einer gesonderten Includedatei abgelegt sind, in die gewünschten Quelldateien einzubinden. Dadurch lässt sich der Aufwand für die Entwicklung und Pflege von User Language-Programmen erheblich reduzieren (eine in verschiedenen Programmen benötigte Funktion muss nur einmal im Quelltext definiert werden). Die Syntax für die #include-Anweisung lautet:

#include "filename" EOLN

Die #include-Anweisung sorgt dafür, dass der User Language Compiler an dieser Stelle mit der Kompilierung der in der #include-Anweisung angegebenen Quellcode-Datei beginnt. Diese Anweisung wird durch das Zeilenende abgeschlossen. Ist das Dateiende der Includedatei erreicht, dann wird der Übersetzungsvorgang an der der #include-Anweisung nachfolgenden Anweisung fortgesetzt. Innerhalb einer Includedatei sind wiederum #include-Anweisungen zulässig, sofern sich dadurch keine Mehrfachbearbeitung identischer Quellcodedateien (Datenrekursion!) ergibt. Bei der Verwendung von #include-Anweisungen ist zu berücksichtigen, dass bestimmte Teile der eingebundenen Includedateien in dem jeweiligen Programm u.U. gar nicht benötigt werden. Man sollte beim Compilerlauf daher in jedem Fall den Optimierer aktivieren, um redundante Programmteile zu eliminieren. Das folgende Beispiel zeigt das Include-File baecall.ulh mit der Routine call zur Aktivierung von AutoEngineer-Menüfunktionen:

// baecall.ulh -- BAE menu call facilities
void call(int menuitem)       // Call a BAE menu function
{
    // Perform the BAE menu call
    if (bae_callmenu(menuitem))
    {
        // Error; print error message and exit from program
        perror("BAE menu call fault!");
        exit(-1);
    }
}

Das folgende Beispiel zeigt den Source-Code für das Programm zoomall zur Ausführung des Zoom All-Kommandos im AutoEngineer; hierbei wird die über das Include-File baecall.ulh eingebundene Routine call verwendet:

// ZOOMALL -- Call the BAE Zoom All command
#include "baecall.ulh"        // BAE menu call include
main()
{
    // Call Zoom All
    call(101);
}

2.6.2 Konstantendefinition

Eine Preprozessor-Anweisung der Form

#define IDENT constexpr EOLN

sorgt dafür, dass im nachfolgenden Programmtext der über IDENT spezifizierte Identifier jeweils durch den Wert des konstanten Ausdrucks (constexpr) ersetzt wird. Die Anweisung wird durch das Zeilenende abgeschlossen. Diese Anweisung eignet sich insbesondere zur Definition wesentlicher Konstanten.

Die Gültigkeit der Konstantendefinition erstreckt sich bis zum Ende des Programmtextes, sofern die Definition nicht vorher durch eine Preprozessor-Anweisung der Form

#undef IDENT EOLN

gelöscht wird.

Eine besondere Form der #define-Anweisung ist durch die Syntax

#define IDENT EOLN

gegeben. Hierbei wird lediglich ein Name definiert, dessen Existenz durch die Preprozessor-Anweisungen #ifdef bzw. #ifndef abgefragt werden kann (siehe hierzu Kapitel 2.6.3).

Typische Beispiele für die Verwendung der #define-Anweisung sind:

#define DDBCLASSLAYOUT 100
#define mmtoinch 25.4
#define inchtomm 1.0/mmtoinch
#define REPABORT "Operation aborted."
#define ERRCLASS "Operation not allowed for this element!"
#define GERMAN  1
#define ENGLISH 0
#define LANGUAGE GERMAN
#define DEBUG

2.6.3 Bedingte Übersetzung

Eine Preprozessor-Anweisung der Form

#if constexpr EOLN

überprüft, ob der angegebene konstante Ausdruck einen von Null verschiedenen Wert besitzt. Eine Preprozessor-Anweisung der Form

#ifdef IDENT EOLN

überprüft, ob der über den Identifier spezifizierte Name (durch eine #define-Anweisung) definiert ist. Eine Preprozessor-Anweisung der Form

#ifndef IDENT EOLN

überprüft, ob der über den Identifier spezifizierte Name unbekannt ist.

Die auf #if, #ifdef bzw. #ifndef folgenden Zeilen des Programmtextes werden nur dann übersetzt, wenn die entsprechende Bedingung erfüllt. Ansonsten wird der entsprechenden Programmteil lediglich auf korrekte Syntax geprüft.

Auf eine If-Preprozessor-Anweisung kann optional eine Prepozessor-Anweisung der Form

#else EOLN

folgen. Durch eine Preprozessor-Anweisung der Form

#endif EOLN

wird die entsprechende If-Konstruktion abgeschlossen. Wenn die If-Bedingung erfüllt ist, dann werden alle Zeilen zwischen #else und #endif von der eigentlichen Übersetzung ausgenommen. Ist die If-Bedingung nicht erfüllt, dann wird der Programmteil zwischen der If-Anweisung und #else (oder in dessen Abwesenheit #endif) von der Übersetzung ausgenommen. Derartige If-Preprozessor-Konstruktionen dürfen verschachtelt sein.

Das folgende Beispiel illustriert die Möglichkeiten der bedingten Übersetzung:

#define ENGLISH 0
#define GERMAN 1
#define LANGUAGE ENGLISH

#if LANGUAGE == GERMAN
#define MSGSTART "Programm gestartet."
#endif
#if LANGUAGE == ENGLISH
#define MSGSTART "Program started."
#endif

#define DEBUG

main()
{
#ifdef DEBUG
    perror(MSGSTART);
#endif
    :
}

2.6.4 BNF-Precompiler

In die Bartels User Language ist ein BNF-Precompiler zur Realisierung von Interface-Programmen für die Bearbeitung von Fremddatenformaten integriert. Unter Verwendung der zugehörigen Scanner- und Parserfunktionen lassen sich in einfacher und eleganter Weise Programme zur Verarbeitung praktisch beliebiger ASCII-Datenformate implementieren.

Jeder User Language-Programmtext darf eine Preprozessor-Anweisung der Form

#bnf { ... }

enthalten. Das #bnf-Statement darf sich über beliebig viele Zeilen des Quelltextes erstrecken. Diese Anweisung aktiviert den BNF-Precompiler des Bartels User Language Compilers. BNF (Backus Naur Form) ist ein Formalismus zur Beschreibung der Syntax einer Sprache. Die BNF-Definition (innerhalb der geschweiften Klammern des #bnf-Statements) einer Sprache besteht aus einer Folge von Regeln durch die die Grammatik der Sprache (d.h. die in dieser Sprache gültigen Folgen von Worten bzw. Zeichen zur Bildung von Sätzen) festgelegt wird. In der BNF-Notation besteht eine Regel aus einem eindeutigen Grammatikbegriff (non-terminal symbol), dem über den Doppelpunkt-Operator : (zu lesen als "besteht aus") eine Folge von einer oder mehreren alternativen (durch das Zeichen | voneinander getrennten) Formulierungen zugewiesen wird. Eine Formulierung wiederum besteht aus einer Folge von Grammatikbegriffen und Eingabesymbolen (terminal symbols), wobei auch leere Formulierungen zulässig sind. Der Grammatikbegriff der ersten Regel einer BNF-Definition wird als Startsymbol bezeichnet. Durch die rekursive Verwendung von Grammatikbegriffen innerhalb der Regeln lassen sich unendlich viele bzw. unendlich lange zulässige Sätze definieren. Die Definition einer jeden Regel ist durch einen Strichpunkt ; abzuschließen.

Die in der BNF-Definition angegebenen Terminalsymbole definieren den Wortschatz, d.h. die Menge der zulässigen Worte der Sprache. Hierbei kennzeichnen die Schlüsselwörter IDENT (Identifier), NUMBER (numerische Konstante), SQSTR (Single Quoted String, Zeichenkette in einfachen Anführungszeichen), DQSTR (Double Quoted String, Zeichenkette in Doppelten Anführungszeichen), EOLN (End Of Line, Zeilenende \n), EOF (End Of File; Dateiende bzw. End of String bei der Abarbeitung von Zeichenketten), EOFINC (End Of Include File, Ende Dateieinbindung) und UNKNOWN (nicht explizit definierte Sonderzeichenketten) nicht näher spezifizierte Terminalsymbole aus den entsprechenden Wortklassen. Die Spezifikation spezieller, anwendungsspezifischer Terminalsymbole geschieht durch die Angabe der entsprechenden Zeichenketten in Anführungszeichen, wobei der BNF-Precompiler automatisch eine Unterteilung in reservierte Worte (Schlüsselwort, Keyword; Identifier bestehend aus mindestens 3 Zeichen) und Operatoren (Single Character Operatoren bestehend aus einem Sonderzeichen bzw. Double Character Operatoren bestehend aus zwei Sonderzeichen) vornimmt.

Beispiele für die Spezifikation von Schlüsselwörtern sind:

"SECTION"   'ENDSEC'   'Inch'   'begin'   "end"   'include'

Beispiele für die Spezifikation von Double Character Operatoren sind:

'<='   '++'   "&&"   "+="   '::'   ':='

Beispiele für die Spezifikation von Single Character Operatoren sind:

'+'   '-'   "*"   "/"   "="   "["   "}"   '#'   '.'

Zwischenräume (Leerzeichen, Tabulatoren, Zeilentrenner) sind üblicherweise bei der Definition einer Grammatik nicht signifikant; sie dienen lediglich der Trennung von benachbarten Symbolen. Auch Kommentare stellen letztendlich nichts anderes als Zwischenräume dar. Von Bedeutung ist in in diesem Zusammenhang lediglich die Definition entsprechender Kommentarbegrenzungs-Operatoren. Per Default trägt der BNF-Precompiler hierfür die Operatoren /* (Kommentarstart) und */ (Kommentarende) für zeilenübergreifende Kommentare ein. Diese Zuordnung lässt sich mit Hilfe eines speziellen Kommandos am Beginn der BNF-Definition ändern. Die diesbezügliche Anweisung für die Defaulteinstellung lautet wie folgt:

COMMENT ('/*', '*/');

Durch die Angabe nur eines Kommentarbegrenzungsoperators wie z.B. in

COMMENT ('//');

werden Kommentare konfiguriert, die sich bis zum Zeilenende erstrecken. Es ist zu beachten, dass die Kommentardefaulteinstellung verloren geht, sobald auch nur eine COMMENT-Anweisung in die BNF-Definition eingetragen wird. Will man also z.B. sowohl /* und */ für zeilenübergreifende Kommentare als auch den Operator // für Kommentare bis zum Zeilenende definieren, dann sind explizit die folgenden beiden COMMENT-Anweisungen am Beginn der BNF-Definition einzutragen:

COMMENT ('/*', '*/');
COMMENT ('//');

Eine Besonderheit des Bartels User Language BNF-Precompilers besteht darin, dass zu jedem in einer Formulierung aufgeführten Grammatikbegriff bzw. Eingabesymbol optional eine Aktion definiert werden kann. Die Definition einer Aktion besteht aus der in runden Klammern (( und )) eingeschlossenen Angabe einer User Language-Anwenderfunktion, die bei Erkennung des entsprechenden Symbols auszulösen ist. Per Konvention müssen diese Anwenderfunktionen vom Datentyp int sein; der Rückgabewert einer solchen Funktion muss Null sein, wenn kein Fehler aufgetreten ist, und (-1) im anderen Fall. Optional ist ein Parameter vom Datentyp int zulässig, welcher in der BNF-Definition als Konstante in runden Klammern nach dem Funktionsnamen anzugeben ist.

Die exakte Definition der Syntax der BNF-Notation ist in der Syntaxdefinition der Bartels User Language (siehe Kapitel 2.7) enthalten.

Der BNF-Precompiler übersetzt die BNF-Definition in User Language-Maschinencode, der eine State-Maschine zur Abarbeitung eines Textes in der definierten Sprache festlegt. Zur Aktivierung dieser State-Maschine stehen die User Language-Systemfunktionen synparsefile und synparsestring zur Verfügung. Die Funktion synparsefile aktiviert einen Parser zur Abarbeitung einer durch Dateinamen spezifizierten Eingabedatei während mit der Funktion synparsestring eine Zeichenkette anstelle eines Dateiinhaltes abgearbeitet werden kann. Beide Funktionen lösen nach Bedarf automatisch die definierten Aktionen bzw. Anwenderfunktionen aus. Innerhalb dieser Anwenderfunktionen kann mit der Systemfunktion synscanline die aktuelle Zeilennummer der Eingabedatei und mit synscanstring die aktuell eingelesene Zeichenkette ermittelt werden, wobei die aktuelle Zeichenkette nach Bedarf auch einer semantischen Prüfung unterzogen werden kann. Die Funktionen synparsefile bzw. synparsestring werden beendet, sobald das Ende der Eingabedatei bzw. des abzuarbeitenden Strings erreicht ist oder ein Syntaxfehler (bzw. ein durch eine Anwenderfunktion erkannter semantischer Fehler) aufgetreten ist.

Der Vollständigkeit halber sei an dieser Stelle noch auf die Systemfunktionen synscaneoln, synscanigncase und synparseincfile hingewiesen. Mit der Scannerfunktion synscaneoln kann die Zeilenendeerkennung des BNF-Parsers aktiviert bzw. deaktiviert werden (default: Zeilenendeerkennung deaktiviert). Die Verwendung des Terminalsymbols EOLN in der BNF-Definition ist demnach nur sinnvoll bzw. zulässig, wenn für die Dateibearbeitung auch die Zeilenendeerkennung aktiviert wird. Mit der Scannerfunktion synscanigncase kann die per Default aktivierte Unterscheidung zwischen Groß- und Kleinschreibung bei der Schlüsselworterkennung deaktiviert bzw. wieder aktiviert werden. Mit der Parserfunktion synparseincfile wird die Bearbeitung einer eingebundenen Datei (Includedatei) aktiviert, d.h. der Parser setzt bei Aufruf dieser Funktion den Einlesevorgang unmittelbar am Beginn der namentlich spezifizierten Includedatei fort. Sobald das Ende der Includedatei erreicht ist, wird das EOFINC Terminalsymbol als erkannt gemeldet, und der Einlesevorgang wird an der in der übergeordneten Datei unterbrochenen Stelle fortgesetzt. Bei Verwendung der Funktion synparseincfile ist demnach auch eine entsprechende Einbindung des Terminalsymbols EOFINC in die BNF-Definition erforderlich (andernfalls ist dieses Terminalsymbol obsolet).

Die genauen Beschreibungen der Scanner- und Parserfunktionen finden sich im Anhang C.

Die Funktionalität des BNF-Precompilers soll an dieser Stelle anhand eines Beispiels zur Übernahme von Bauteil-Platzierungsdaten in das aktuell im Layouteditor geladene Layout verdeutlicht werden. Die Eingabedaten sollen dabei nach folgendem Schema aufgebaut sein:

// This is a comment @

LAYOUT    # This is a comment extending to the end of line

UNITS {
    LENGTH = ( 1.0 INCH ) ;
    ANGLE  = ( 1.0 DEGREE ) ;
    }

PLACEMENT {
    'ic1' : 'dil16' {
        POSITION = (0.000,0.000) ;
        ROTATION = 0.000 ;
        MIRROR   = 0 ;
        }
    'ic2' : 'dil16' {
        POSITION = (2.250,0.100) ;
        }
    'ic3' : 'dil16' {
        POSITION = (1.000,0.394) ;
        ROTATION = 23.500 ;
        }
    'ic4' : 'so16' {
        POSITION = (0.000,0.700) ;
        ROTATION = 0.000 ;
        MIRROR   = 1 ;
        }
    }

END

Das Programm zum Einlesen von Platzierungsdaten aus externen Dateien gemäß obigem Beispiel kann unter Verwendung des BNF-Precompilers und der Scanner- und Parserfunktionen auf folgende Weise implementiert werden:

// READLPLC -- Read Layout Placement from ASCII File
//_________________________________________________________
// BNF input syntax definition
#bnf {
      COMMENT ("//", "@") ;
      COMMENT ("#") ;
      placefile
              : "LAYOUT" placeunits placedata "END"
              ;
      placeunits
              : "UNITS" "{"
                "LENGTH" "=" "(" floatnum placelengthunit ")" ";"
                "ANGLE" "=" "(" floatnum placeangleunit ")" ";"
                "}"
              ;
      placelengthunit
              : "INCH" (p_unitl(1))
              | "MM" (p_unitl(2))
              | "MIL" (p_unitl(3))
              ;
      placeangleunit
              : "DEGREE" (p_unita(1))
              | "RAD" (p_unita(2))
              ;
      placedata
              : "PLACEMENT" "{" placecommands "}"
              ;
      placecommands
              : placecommands placecommand
              |
              ;
      placecommand
              : identifier (p_pname) ":" identifier (p_plname)
                "{" placepos placerot placemirror "}" (p_storepart)
              ;
      placepos
              : "POSITION" "="
                "(" floatnum (p_px) "," floatnum (p_py) ")" ";"
              ;
      placerot
              : "ROTATION" "=" floatnum (p_pa) ";"
              |
              ;
      placemirror
              : "MIRROR" "=" NUMBER (p_pm) ";"
              |
              ;
      identifier
              : SQSTR (p_ident)
              ;
      floatnum
              : NUMBER (p_fltnum(0))
              | "-" NUMBER (p_fltnum(1))
              ;
}

//______________________________________________________________
// Globals
double plannx=bae_planwsnx(); // Element origin X coordinate
double planny=bae_planwsny(); // Element origin Y coordinate
double lenconv;               // Length conversion factor
double angconv;               // Angle conversion factor
string curpn;                 // Current part name
string curpln;                // Current physical library name
double curx,cury;             // Current coordinates
double cura = 0.0;            // Current angle (default: 0.0)
int curm = 0;                 // Current mirror flag (default: 0)
string curid;                 // Current identifier
double curflt;                // Current float value
struct partdes {              // Part descriptor
      string pn;              //  Part name
      string pln;             //  Physical library name
      double x,y;             //  Coordinates
      double a;               //  Angle
      int m;                  //  Mirror flag
      } pl[];                 // Part list
int pn=0;                     // Part count

//______________________________________________________________
// Main program
main()
{
      string fname;           // Input file name
      // Test if layout loaded
      if (bae_planddbclass()!=100)
              errormsg("Command not allowed for this element!","");
      // Get and test the placement file name
      if ((fname=askstr("Placement File : ",40))=="")
              errormsg("Operation aborted.","");
      // Parse the placement file
      perror("Reading placement data...");
      parseerr(synparsefile(fname),fname);
      // Perform the placement
      placement();
      // Done
      perror("Operation completed without errors.");
}

//______________________________________________________________
// Part list management and placement

void gcpart()
// Get or create some part list entry
{
      index L_CPART cpart;    // Part index
      index L_NREF nref;      // Named reference index
      int slb=0;              // Search lower boundary
      int sub=pn-1;           // Search upper boundary
      int idx;                // Search index
      int compres;            // Compare result
      // Loop until search area empty
      while (slb<=sub) {
              // Get the search index
              idx=(slb+sub)>>1;
              // Get and test the compare result
              if ((compres=strcmp(curpn,pl[idx].pn))==0)
                      errormsg("Multiple defined part '%s'!",curpn);
              // Update the search area
              if (compres<0)
                      sub=idx-1;
              else
                      slb=idx+1;
              }
      // Check if part is placed already
      forall (nref where curpn==nref.NAME)
              // Part already placed; abort
              return;
      // Check net list consistence
      forall (cpart where curpn==cpart.NAME) {
              // Check the plname
              if (curpln!=cpart.PLNAME)
                      // Netlist definition mismatch
                      errormsg("Wrong part macro name '%s'!",curpln);
              // Done
              break;
              }
      // Insert the new entry to the part list
      pn++;
      for (idx=pn-2;idx>=slb;idx--)
              pl[idx+1]=pl[idx];
      pl[slb].pn=curpn;
      pl[slb].pln=curpln;
      pl[slb].x=curx;
      pl[slb].y=cury;
      pl[slb].a=cura;
      pl[slb].m=curm;
}

void placement()
// Perform the placement
{
      int i;                  // Loop control variable
      // Iterate part list
      for (i=0;i<pn;i++) {
              // Place the part
              if (ged_storepart(pl[i].pn,pl[i].pln,
               pl[i].x,pl[i].y,pl[i].a,pl[i].m))
                      errormsg("Error placing part '%s'!",pl[i].pn);
              }
}

//______________________________________________________________
// Error handling

void parseerr(status,fn)
// Handle a syntax/parser error
int status;                   // Scan status
string fn;                    // File name
{
      string msg;             // Error message
      // Evaluate the scan status
      switch (status) {
              case 0 : // No error
              return;
              case 1 :
              msg="No BNF definition available!";
              break;
              case 2 :
              msg="Parser already active!";
              break;
              case 3 :
              sprintf(msg," Error opening file '%s'!",fn);
              break;
              case 4 :
              msg="Too many open files!";
              break;
              case 5 :
              sprintf(msg,"[%s/%d] Fatal read/write error!",
               fn,synscanline());
              break;
              case 6 :
              sprintf(msg,"[%s/%d] Scan item '%s' too long!",
               fn,synscanline(),synscanstring());
              break;
              case 7 :
              sprintf(msg,"[%s/%d] Syntax error at '%s'!",
               fn,synscanline(),synscanstring());
              break;
              case 8 :
              sprintf(msg,"[%s/%d] Unexpected end of file!",
               fn,synscanline());
              break;
              case 9 :
              sprintf(msg,"[%s/%d] Stack overflow (BNF too complex)!",
               fn,synscanline());
              break;
              case 10 :
              sprintf(msg,"[%s/%d] Stack underflow (BNF erroneous)!",
               fn,synscanline());
              break;
              case 11 :
              sprintf(msg,"[%s/%d] Error from parse action function!",
               fn,synscanline());
              break;
              default :
              sprintf(msg,"Unknown parser error code %d!",status);
              break;
              }
      // Print the error message
      errormsg(msg,"");
}

void errormsg(string errfmt,string erritem)
// Print an error message with error item and exit from program
{
      string errmsg;          // Error message string
      // Build and print the error message string
      sprintf(errmsg,errfmt,erritem);
      perror(errmsg);
      // Exit from program
      exit(-1);
}

//______________________________________________________________
// Parser action routines

int p_unitl(code)
// Handle the length units definition request
// Returns : zero if done or (-1) on error
{
      // Set the length conversion factor
      switch (code) {
              case 1 : lenconv=cvtlength(curflt,1,0); break; // Inch
              case 2 : lenconv=cvtlength(curflt,2,0); break; // mm
              case 3 : lenconv=cvtlength(curflt,3,0); break; // mil
              default : return(-1); // Error
              }
      // Return without errors
      return(0);
}

int p_unita(code)
// Handle the angle units definition request
// Returns : zero if done or (-1) on error
{
      // Set the angle conversion factor
      switch (code) {
              case 1 : angconv=cvtangle(curflt,1,0); break; // Deg
              case 2 : angconv=cvtangle(curflt,2,0); break; // Rad
              default : return(-1); // Error
              }
      // Return without errors
      return(0);
}

int p_storepart()
// Handle the store part request
// Returns : zero if done or (-1) on error
{
      // Get or create the part list entry
      gcpart();
      // Re-init the current angle and mirror mode
      cura=0.0;
      curm=0;
      // Return without errors
      return(0);
}

int p_pname()
// Receive a part name
// Returns : zero if done or (-1) on error
{
      // Store the current part name
      strlower(curpn=curid);
      // Return without errors
      return(0);
}

int p_plname()
// Receive a physical library name
// Returns : zero if done or (-1) on error
{
      // Store the current physical library name
      strlower(curpln=curid);
      // Return without errors
      return(0);
}

int p_px()
// Receive a part X coordinate
// Returns : zero if done or (-1) on error
{
      // Store the current part X coordinate
      curx=curflt*lenconv+plannx;
      // Return without errors
      return(0);
}

int p_py()
// Receive a part Y coordinate
// Returns : zero if done or (-1) on error
{
      // Store the current part Y coordinate
      cury=curflt*lenconv+planny;
      // Return without errors
      return(0);
}

int p_pa()
// Receive a part angle
// Returns : zero if done or (-1) on error
{
      // Store the current part angle
      cura=curflt*angconv;
      // Return without errors
      return(0);
}

int p_pm()
// Receive a part mirror flag
// Returns : zero if done or (-1) on error
{
      // Get and store the current part mirror flag
      curm=atoi(synscanstring())==0?0:1;
      // Return without errors
      return(0);
}

int p_ident()
// Receive an identifier
// Returns : zero if done or (-1) on error
{
      // Store the current string
      curid=synscanstring();
      // Return without errors
      return(0);
}

int p_fltnum(negflag)
// Receive a float value
// Returns : zero if done or (-1) on error
int negflag;                  // Negative number flag
{
      // Get the current float value
      curflt=atof(synscanstring());
      // Set negative on request
      if (negflag)
              curflt*=(-1);
      // Return without errors
      return(0);
}

//______________________________________________________________
// User Language program end

2.6.5 Programmaufruftyp und Undo-Mechanismus

Setzen des Programmaufruftyps

Über die Preprozessoranweisung #pragma kann der Aufruftyp des generierten User Language-Programms explizit gesetzt werden. Damit kann bei der Kompilierung ungeachtet der Verwendung modulspezifischer Systemfunktionen oder Indexvariablen die Kompatibilität des User Language-Programms erweitert oder eingeschränkt werden. Es können die in der nachfolgenden Tabelle angegebenen Aufruftypen spezifiziert werden (siehe hierzu auch Anhang A.1.2).

Mit der Preprozessoranweisung

#pragma ULCALLERSTD

kann der Aufruftyp des generierten User Language-Programms explizit auf Standard (STD) gesetzt werden. Ohne obige Preprozessoranweisung quittiert der User Language Compiler die Verwendung von Funktionen und Indexvariablen zueinander inkompatibler Aufruftypen mit der Fehlermeldung Inkompatible Index-/Funktions-Referenz(en)!. Bei Verwendung obiger #pragma-Anweisung ist das generierte Programm in allen Interpreterumgebungen aufrufbar, auch wenn im Programm zur aktuellen Interpreterumgebung inkompatible Indexvariablen oder Funktionen verwendet werden. Es liegt dann in der Verantwortung des Programmierers, den Programmfluss so zu steuern, dass nur solche Indexvariablen bzw. Funktionen tatsächlich referenziert bzw. aufgerufen werden, die zur aktuellen Interpreterumgebung kompatibel sind. Damit lassen sich Programme mit ähnlicher Funktionalität für unterschiedliche Interpreterumgebungen implementieren. Sollte es zur Programmlaufzeit dennoch zu Zugriffen auf inkompatible Indexvariablen oder Funktionen kommen, dann bricht der User Language Interpreter das Programm mit einer entsprechenden Fehlermeldung (UL(Zeile): System-Funktion in dieser Umgebung nicht verfuegbar!) ab.

Undo-Mechanismus konfigurieren

Die Ausführung eines User Language-Programms generiert per Standard einen Undoschritt im BAE-System. Die Präprozessoranweisung

#pragma ULCALLERNOUNDO

deaktiviert den Undo-Mechanismus für das kompilierte Programm. Damit können redundante Undoschritte für Programme, die keine für das Undo relevanten Operationen ausführen, vermieden werden.

2.7 Syntaxdefinition

Nachfolgend ist die Definition der User Language-Syntax in BNF(Backus-Naur-Form)-ähnlicher Notation aufgelistet. Kommentare sind dabei durch /* und */ begrenzt. Der Doppelpunkt (:) entspricht einem Zuweisungs-Operator und ist folglich zu lesen als "besteht aus". Das Zeichen | kennzeichnet Alternativen. Identifier werden durch das Symbol IDENT, Konstanten durch NUMBER (numerisch), SQSTR (Zeichen) und DQSTR (Zeichenkette) gekennzeichnet. Das Symbol EOLN definiert das Zeilenende. Die Terminalzeichen-Sequenzen (also die reservierten Worte und Operatoren) sind fett gedruckt dargestellt.

/* User Language Source Code Syntax */

/* Program definition */

program
        : progdefs
        ;

progdefs
        : progdefs progdef
        |
        ;

progdef
        : preproccmd
        | typedef
        | storageclass vardef
        | storageclass fctdef
        ;

/* Preprocessor command */

preproccmd
        : #include DQSTR EOLN
        | #define IDENT optexpr EOLN
        | #undef IDENT EOLN
        | #if expression EOLN
        | #ifdef IDENT EOLN
        | #ifndef IDENT EOLN
        | #else EOLN
        | #endif EOLN
        | #bnf { syntaxdef } 
        | #pragma pragmaval
        ;

pragmaval
        : ULCALLERSTD
        | ULCALLERCAP
        | ULCALLERSCM
        | ULCALLERLAY
        | ULCALLERGED
        | ULCALLERAR
        | ULCALLERCAM
        | ULCALLERCV
        | ULCALLERICD
        | ULCALLERCED
        | ULCALLERNOUNDO
        ;

/* Type definition */

typedef
        : typedef declaration
        ;

/* Variable definition */

vardef
        : typespec initdecs ; 
        ;

/* Function definition */

fctdef
        : fcttype IDENT ( fctpars ) fctpardecs { cmditems }         ;

fcttype
        : typespec
        | void 
        |
        ;

fctpars
        : fctpardefs
        |
        ;

fctpardefs
        : fctpardefs , IDENT
        | IDENT
        ;

fctpardecs
        : fctpardecs vardef
        |
        ;

/* Storage class */

storageclass
        | static 
        | structdef
        ;

/* Type specification */

typespec
        : int 
        | double 
        | char 
        | string 
        | index IDENT
        | structdef
        | IDENT
        ;

/* Struct definition */

structdef
        : struct IDENT
        | struct IDENT { members } 
        | struct { members } 
        ;

members
        : members declaration
        | declaration
        ;

/* Declaration */

declaration
        : typespec decs ; 
        ;

decs
        : decs , declarator
        | declarator
        ;

/* Initialized declarator list */

initdecs
        : initdecs , initdec
        | initdec
        |
        ;

initdec
        : declarator
        | declarator = initializer
        ;

/* Declarator */

declarator
        : IDENT
        | declarator [ ] 
        ;

/* Initializer */

initializer
        : assignment
        | { initializers } 
        ;

initializers
        : initializers , initializer
        | initializer
        ;

/* Command block */

cmdblock
        : { cmditems } 
        | cmditem
        ;

/* Command list */

cmditems
        : cmditems cmditem
        |
        ;

/* Command item */

cmditem
        : preproccmd
        | typedef
        | vardef
        | ifcmd
        | switchcmd
        | forcmd
        | whilecmd
        | docmd
        | forallcmd
        | return optexpr ; 
        | break ; 
        | continue ; 
        | optexpr ; 
        ;

/* If control structure */

ifcmd
        : if ( expression ) cmdblock elsecmd
        ;

elsecmd
        : else cmdblock
        |
        ;

/* Switch control structure */

switchcmd
        : switch ( expression ) { caseblocks } 
        ;

caseblocks
        : caseblocks caseblock
        |
        ;

caseblock
        : cases cmditems
        ;

cases
        : cases case
        | case
        ;

case
        : case expression : 
        | default : 
        ;

/* For control structure */

forcmd
        : for ( optexpr ; optexpr ; optexpr ) cmdblock
        ;

/* While control structure */

whilecmd
        : while ( expression ) cmdblock
        ;

/* Do control structure */

docmd
        : do cmdblock while ( expression ) ; 
        ;

/* Forall control structure */

forallcmd
        : forall ( IDENT forallof forallwhere ) cmdblock
        ;

forallof
        : of IDENT
        |
        ;

forallwhere
        : where expression
        |
        ;

/* Expression */

optexpr
        : expression
        |
        ;

expression
        : expression , assignment
        | assignment
        ;

/* Assignment */

assignment
        : unary = assignment
        | unary |= assignment
        | unary ^= assignment
        | unary &= assignment
        | unary <<= assignment
        | unary >>= assignment
        | unary += assignment
        | unary -= assignment
        | unary *= assignment
        | unary /= assignment
        | unary %= assignment
        | conditional
        ;

/* Conditional evaluation */

conditional
        : log_or
        | log_or ? conditional : conditional
        ;

/* Logical OR */

log_or
        : log_and
        | log_and || log_or
        ;

/* Logical AND */

log_and
        : bit_or
        | bit_or && log_and
        ;

/* Bit OR */

bit_or
        : bit_xor
        | bit_or | bit_xor
        ;

/* Bit Exclusive OR */

bit_xor
        : bit_and
        | bit_xor ^ bit_and
        ;

/* Bit AND */

bit_and
        : equality
        | bit_and & equality
        ;

/* Equivalence comparison */

equality
        : comparison
        | equality == comparison
        | equality != comparison
        ;

/* Comparison */

comparison
        : shift
        | comparison < shift
        | comparison <= shift
        | comparison > shift
        | comparison >= shift
        ;

/* Shift operations */

shift
        : sum
        | shift << sum
        | shift >> sum
        ;

/* Addition and substraction */

sum
        : product
        | sum + product
        | sum - product
        ;

/* Multiplication and division */

product
        : unary
        | product * unary
        | product / unary
        | product % unary
        ;

/* Unary operators */

unary
        : primary
        | primary ++ 
        | primary -- 
        | - unary
        | ! unary
        | ~ unary
        | ++ unary
        | -- unary
        ;

/* Primary operators */

primary
        : IDENT
        | NUMBER
        | SQSTR
        | DQSTR
        | ( expression ) 
        | IDENT ( optexpr ) 
        | primary [ expression ] 
        | primary . IDENT
        ;

/* BNF Precompiler syntax definition */

syntaxdef
        : commentdef grammar
        ;

commentdef
        : COMMENT ( commentdel commentend ) ; 
        |
        ;

commentend
        : , commentdel
        |
        ;

commentdel
        : SQSTR
        | DQSTR
        ;

grammar
        : grammar rule
        | rule
        ;

rule
        : IDENT : forms ; 
        | IDENT : forms | ; 
        ;

forms
        : form | forms
        | form
        ;

form
        : form symbol action
        | symbol action
        ;

symbol
        : IDENT
        | SQSTR
        | DQSTR
        | IDENT 
        | NUMBER 
        | SQSTR 
        | DQSTR 
        | EOLN 
        | EOF 
        | EOFINC 
        | UNKNOWN 
        ;

action
        | ( IDENT ( NUMBER ) ) 
        | ( IDENT ) 
        |
        ;

/* BNF syntax description file end */

3 Programmiersystem

Inhalt

3.1.1

Programmspeicherung

3.1.2

Maschinenarchitektur

3.2.1

Arbeitsweise

3.2.2

Compileraufruf

3.2.3

Fehlerbehandlung

3.3.1

Arbeitsweise

3.3.2

Programmaufruf

3.3.3

Fehlerbehandlung

3-1

User Language Maschinen-Befehlssatz

3-2

Tastaturgesteuerter Programmaufruf

3-3

Ereignisgesteuerter Programmaufruf

3.1 Konventionen

Das Bartels User Language-Programmiersystem besteht aus dem User Language Compiler und dem User Language Interpreter. Der Compiler hat die Aufgabe, User Language-Quellcode in User Language-Maschinencode (Programme oder Libraries) zu übersetzen und nach Bedarf statische Linkprozesse durchzuführen bzw. notwendige Informationen für dynamische Linkprozesse zu generieren. Mit Hilfe des Interpreters werden User Language-Maschinenprogramme geladen, nach Bedarf dynamisch gelinkt, und schließlich ausgeführt bzw. abgearbeitet. Da User Language Compiler und User Language Interpreter zeitlich unabhängig voneinander arbeiten, also in unterschiedlichen Programmen implementiert sind, müssen die nachfolgend beschriebenen Konventionen hinsichtlich des Programmzugriffs eingehalten werden.

3.1.1 Programmspeicherung

Der Compiler legt fehlerfrei übersetzte Programme und Libraries unter ihrem jeweiligen Namen in der Datei ulcprog.vdb im Programmverzeichnis des Bartels AutoEngineer ab. Mit dem Maschinencode wird dabei die Versionsnummer des User Language Compilers sowie der Aufruftyp (eine Kodierung für die zum Programm kompatible Interpreterumgebung) abgelegt. Darüber hinaus werden nach Bedarf auch notwendige Informationen für dynamische (d.h. zur Laufzeit durchzuführende) Linkprozesse abgespeichert. Der Interpreter lädt beim Programmaufruf das entsprechende Programm über seinen Namen aus der Datei ulcprog.vdb des BAE-Programmverzeichnisses. Dabei wird mit Hilfe der User Language-Versionsnummer geprüft, ob das Programm mit einer zum Interpreter kompatiblen Compiler-Version erzeugt wurde (andernfalls bestünde die Gefahr, dass der Interpreter die Programmstruktur gar nicht versteht). Über den Aufruftyp erfolgt die Prüfung der Kompatibilität des Programms zur aktuellen Interpreterumgebung; dies ist notwendig, um sicherzustellen, dass während der Programmausführung keine Index-Variablen-Typen oder Systemfunktionen referenziert werden, die in der aktuellen Interpreterumgebung gar nicht implementiert sind. Während der Programmladephase führt der Interpreter nach Bedarf automatisch die für den Programmlauf notwendigen dynamischen Linkprozesse durch, wobei die einzubindenden Libraries ebenfalls einer Kompatibilitätsprüfung unterzogen werden.

3.1.2 Maschinenarchitektur

Die in der User Language implementierte Maschinenarchitektur entspricht der einer Stackmaschine. Der darin definierte Befehlssatz (Instruction Set) umfasst Ladebefehle (zum Laden von Variablen- oder Konstantenwerten), ALU-Befehle (zur Aktivierung der arithmetisch-logischen Einheit der Maschine), Speicherbefehle (für Zuweisungen), Sprungbefehle (zur Realisierung von Alternativen und Repetitionen), Befehle zum Aufruf und Beendigen von Funktionen, sowie Befehle zur direkten Manipulation des Stacks.

Der Befehlssatz (Instruction Set) dieser Maschine ist in Tabelle 3-1 aufgelistet; die in den Stackspalten eingetragenen Werte geben dabei für jede Instruktion an, wie viele Argumente auf dem Stack erforderlich sind, und wie die Stackgröße durch die Abarbeitung der Instruktion verändert wird.

Tabelle 3-1: User Language Maschinen-Befehlssatz

3.2 Compiler

Der User Language Compiler dient dazu, User Language-Quelltext in User Language-Maschinenprogramme bzw. in User Language-Libraries zu übersetzen. User Language-Programme können vom User Language Interpreter ausgeführt werden. User Language-Libraries werden üblicherweise aus häufig benötigten Quelltexten erzeugt. Der Maschinencode von User Language-Libraries kann wahlweise statisch (während der Kompilierung durch den User Language Compiler) oder dynamisch (während der Laufzeit durch den User Language Interpreter) eingebunden werden in anderen Maschinencode (Programme oder Libraries). Der Vorteil des Librarykonzepts besteht darin, dass häufig benötigte Quelltexte nur einmal der zeitaufwändigen Kompilierung unterzogen werden müssen; anschließend kann der entsprechende Maschinencode über die sehr viel schnelleren Linkprozesse referenziert werden.

3.2.1 Arbeitsweise

Der User Language Compiler übersetzt User Language-Quelltext in User Language-Maschinencode (User Language-Programme oder User Language-Libraries). Bei der Kompilierung führt der Compiler eine umfassende Konsistenzprüfung des Quelltextes hinsichtlich Syntax und Semantik durch, befreit das Programm bzw. die Library von Redundanzen und erzeugt schließlich - in sehr kompakter Form - einen zum Quelltext äquivalenten Maschinencode. Nach Bedarf werden durch den im User Language Compiler integrierten Linker statische Linkprozesse durchgeführt bzw. notwendige Informationen für dynamische Linkprozesse generiert. Dies alles geschieht in der nachfolgend beschriebenen Abfolge von Arbeitsschritten.

Syntaxanalyse und Semantikprüfung

Im ersten Schritt der Kompilierung erfolgt die syntaktische Analyse des Quelltextes. Über einen Parser-Lauf werden dabei die formalen Probleme behandelt, ob also die in der Quelltextdatei enthaltene Sequenz von Worten und Zeichen ein syntaktisch gültiges User Language-Programm (bzw. eine korrekte User Language-Library) darstellt. Bereits während der Syntaxanalyse wird der Teil der Semantikprüfung durchgeführt, der die im Programm enthaltenen Definitionen (für Variablen, Parameter und Funktionen) auf Konsistenz und Eindeutigkeit in Bezug auf deren Geltungsbereiche prüft. Ergebnis dieses ersten Parser-Laufes (Pass 1) ist eine interne Symboltabelle, die für den zweiten Parser-Lauf (Pass 2) zur semantischen Prüfung benötigt wird. Die semantische Prüfung umfasst die kontext-sensitive Analyse des Quelltextes. Ziel dabei ist es, den Missbrauch der im Programm bzw. in der Library definierten Objekte zu unterbinden. Es wird also die Gültigkeit der Verwendung von Namen ebenso geprüft, wie die Zulässigkeit der Operationen auf die im Programm bzw. in der Library definierten Objekte.

Generierung des Maschinencodes

Bereits während der Semantikprüfung, d.h. im zweiten Parser-Durchlauf (Pass 2) wird der zum Quelltext äquivalente Maschinencode konstruiert. Nur wenn die semantische Prüfung vollständig durchgeführt wurde, und dabei keine Fehler auftraten, entspricht der erzeugte Maschinencode auch einem ausführbaren Maschinenprogramm bzw. einer korrekten User Language-Library.

Linker

Mit dem im User Language Compiler integrierten Linker können optional statische Linkprozesse durchgeführt bzw. notwendige Informationen zur Durchführung dynamischer Linkprozesse generiert werden.

Beim statischen Linken (Compiler-Option -lib) bindet der User Language Compiler den Maschinencode der angeforderten User Language-Libraries direkt in den Maschinencode des aktuell übersetzten Quelltextes ein. Dabei werden die angeforderten Libraries sowie die darin referenzierten Objekte (Funktionen, Variablen, etc.) einer Kompatibilitäts- und Konsistenzprüfung unterzogen.

Beim dynamischen Linken (Compiler-Option -dll) simuliert der User Language Compiler lediglich die Einbindung des Maschinencodes der angeforderten User Language-Libraries. Resultat dieses Prozesses sind Relokationstabellen mit Informationen zur Auflösung der Bibliotheksreferenzen. Diese Relokationstabellen werden mit dem zu übersetzenden Maschinencode abgespeichert und später vom User Language Interpreter zur Laufzeiteinbindung der angeforderten Dynamic Link Libraries verwendet. Bei Änderungen an User Language-Libraries ist zu beachten, dass alle diejenigen User Language-Programme und User Language-Libraries, die Anforderungen zum dynamischen Linken der geänderten Libraries enthalten, neu kompiliert werden müssen.

Optimierer

Der Optimierer des User Language Compilers kann mit der Option -O aktiviert werden. Er hat die Aufgabe, den zuvor erzeugten Maschinencode von Redundanzen zu befreien und den Maschinencode durch Änderungen effizienter zu gestalten. Der Optimierer erkennt und eliminiert dabei nicht erreichbare Code-Segmente sowie nicht referenzierte Funktions-, Variablen- und Parameterdefinitionen. Er wandelt soweit möglich Variablenreferenzen in Konstantenzugriffe um (Constant Propagation), und er führt algebraische Optimierungen durch. Durch den Einsatz des Optimierers ergibt sich in aller Regel eine signifikante Reduzierung des Speicherplatzbedarfs und der Laufzeit für den Maschinencode ergibt.

Auf einen ausgesprochen nützlichen Nebeneffekt der Optimierung sei ausdrücklich hingewiesen: in einem durch den Optimierer modifizierten Maschinencode lassen sich u.U. Programmierfehler lokalisieren, die der Compiler sonst nicht erkannt hätte.

Prüfung des Maschinencodes

Nachdem der Maschinencode fertig erzeugt ist, wird er nochmals auf schwerwiegende Programmierfehler geprüft. Zu dieser Kategorie von Fehlern zählen die Division durch Null, die Konstruktion von Endlos-Schleifen und endlos-rekursive Funktionsaufrufe, die der Compiler durch die Analyse des Maschinencodes u.U. erkennen kann.

Ausgabe einer Listingdatei

Der User Language Compiler kann optional zur Ausgabe einer Listingdatei veranlasst werden. Die Angaben in dieser Datei sind u.U. nützlich bei der Lokalisierung von Fehlern, die erst zur Laufzeit, also bei der Programmausführung auftreten. Der vollständige Inhalt der Listingdatei besteht aus allgemeinen Angaben zum Programm bzw. zur Library (Name, Version, Aufruftyp), Verweisen auf die im Maschinencode referenzierten Libraries bzw. Library-Definitionen, der Auflistung der im Maschinencode statisch eingebundenen Libraries und der im Maschinencode definierten Objekte (Funktionen, Variablen, Strukturen, usw.) sowie der Auflistung des Maschinencodes selbst (Liste der Instruktionen mit Angabe der Quelltextzeilennummer und der äquivalenten Zeilennummer(n) im Maschinencode).

Die Ausführlichkeit der auszugebenden Information kann über verschiedene Modi der Listing-Option -l des User Language Compilers kontrolliert werden, wodurch z.B. vom Inhalt her eingeschränkte Listingdateien zur Dokumentation von User Language-Libraries (Funktionsreferenzen) erzeugt werden können.

Die Option -ld gestattet die Spezifikation eines alternativen Verzeichnisses für die mit der Option -l auszugebenden Listindateien. Dies ist insbesondere bei der Verwendung von make-Utilities zur automatisierten Compilierung geänderter User Language-Programme nützlich, um das Quellverzeichnis "sauber" zu halten. Im Verzeichnis baeulc wird ein makefile bereitgestellt, das die Abhägigkeiten der User Language-Programme von Includedateien enthält und mit Listingdateien in einem Unterverzeichnis (lst) arbeitet.

Speicherung des Maschinencodes

Der letzte Schritt des Compiler-Laufes besteht in der Speicherung des erzeugten Maschinenprogramms bzw. der generierten User Language-Library. Der User Language Compiler legt per Default das Maschinenprogramm (bzw. die User Language-Library) als Datenbankeintrag unter dem beim Compileraufruf spezifizierten Elementnamen (siehe Compiler-Optionen -Source, -cp, -cl) in der Datei ulcprog.vdb im Programmverzeichnis des Bartels AutoEngineer ab. User Language-Programme und User Language-Libraries werden dabei jeweils einer eigenen Datenbankklasse zugeordnet.

Mit Hilfe spezieller Compiler-Optionen ist auch das Löschen von User Language-Programmen (Option -dp) und User Language-Libraries (Option -dl) aus der Datei ulcprog.vdb möglich. Damit kann die Datei ulcprog.vdb von veraltetem bzw. nicht mehr benötigtem Maschinencode bereinigt werden.

3.2.2 Compileraufruf

Der Compileraufruf startet die Übersetzung von User Language-Programmen bzw. von User Language-Libraries.

Synopsis

Der Aufruf des User Language Compilers erfolgt auf Betriebssystemebene. Die Aufrufsyntax lautet:

ulc [-wcon|-wcoff] [[-S[ource]] srcfile...]
    [-lib libname...] [-dll libname...]
    [{-cp|-cl} [dstname...]]
    [-I[nclude] includepath...] [-D[efine] macroid...]
    [-O[0|1]] [-e[0|1]] [-w[0|1|2|3|4]] [-t[0|1]]
    [-l[0|1|2|3|4|5]] [-ld listingdirectory]
    [-dp prgname...] [-dl libname...]
    [-ulp prgfilename] [-ull libfilename]
    [-log logfilename]

Bei einem syntaktisch falschen Aufruf des User Language Compiler wird die korrekte Aufrufsyntax des Compilers angezeigt, und der Compiler-Lauf wird abgebrochen.

Optionen

Die Kommandozeilenoptionen des User Language Compilers bestehen aus einem Bindestrich (-) oder einem Schrägstrich (/) gefolgt von der Optionsspezifikation. Optionspezifikationen, die nur aus einem Buchstaben und der wahlweisen Angabe einer numerischen Modus- oder Schalterangabe bestehen, bezeichnet man häufig als Switches oder Flags. Diese speziellen Optionen können wahlweise gruppiert werden wie z.B. in /l2Ow3 oder -O1w3l2, wo jeweils der Modus 2 für die Listingausgabe selektiert, der Optimierer aktiviert und der Warning Severity Level auf 3 gesetzt werden.

Wildcard Option [-wcon|-wcoff]

Mit Hilfe dieser Option kann die Berücksichtigung von Wildcards bei der Spezifikation von Datei- und Elementnamen aktiviert (Option -wcon; Default) bzw. deaktiviert (Option -wcoff) werden. Ist die Wildcarderkennung aktiviert, dann erlangen die Zeichen ? und * Sonderbedeutung bei der Spezifikation von Datei- und Elementnamen; ? ist dann Platzhalter für ein beliebiges Zeichen, * ist dann Platzhalter für eine beliebige Anzahl beliebiger Zeichen. Die Deaktivierung der Wildcarderkennung ist notwendig, um die Bearbeitung von Programmnamen wie z.B. scm_? oder ged_* zu ermöglichen.

Source File Option [[-S[ource]] srcfile...]

Mit dieser Option werden die Namen der zu übersetzenden Quelltextdateien spezifiziert. Die Dateinamen dürfen dabei Verzeichnispfade enthalten, d.h. die Quelltextdateien müssen nicht notgedrungen im aktuellen Verzeichnis abgelegt sein. Bei der Auswertung von Dateinamen werden Wildcards berücksichtigt, sofern die Wildcarderkennung mit der Option -wcon (siehe oben) aktiviert ist. Dateinamen können wahlweise mit oder ohne Namenserweiterung spezifiziert werden. Wird die Namenserweiterung weggelassen, dann für der Compiler automatisch die Extension .ulc an die entsprechenden Dateinamen an. Quelltextdateinamen mit anderen Namenserweiterungen der müssen also mit ihrer Extension spezifiziert werden. Damit ist es dann allerdings auch möglich, z.B. User Language-Libraries aus Includedateien mit der Extension .ulh zu erzeugen. Der Type des zu erzeugenden Maschinencodes wird mit den Optionen -cp (für User Language-Programme; siehe unten) bzw. -cl (für User Language-Libraries) festgelegt. Der Elementname des erzeugten Maschinencodes ergibt sich aus dem Quelltextdateinamen, wobei der Verzeichnispfad und die Dateinamenserweiterung weggelassen werden. Ein von dieser Konvention abweichender Name für den Maschinencode kann mit den Optionen -cp bzw. -cl (siehe unten) spezifiziert werden. Das Schlüsselwort -Source bzw. -S ist bei der Spezifikation von Quelltextendateinamen nur dann erforderlich, wenn sich sonst Mehrdeutigkeiten bei der Auswertung der Kommandozeile ergeben könnten. Dies ist z.B. dann nicht der Fall, wenn die Quelltextdateinamen die ersten Namensargumente im Compileraufruf darstellen. Mit Hilfe der Schlüsselworte -Source bzw. -S können andererseits jedoch an beliebigen Stellen in der Kommandozeile Quelltextdateien spezifiziert. Ist weder die Option -dp noch die Option -dl (siehe unten) spezifiziert, dann erwartet der User Language Compiler die Angabe von zumindest einer Quelltextdatei.

Static Link Option [-lib libname...]

Die Static Link Option -lib erwartet den Namen einer oder mehrerer User Language-Libraries sowie die Spezifikation von zumindest einer Quellcodedatei (siehe oben, Option -Source). Die mit -lib angeforderten Libraries müssen in kompilierter Form in der Datei ulcprog.vdb im BAE-Programmverzeichnis verfügbar sein. Der im User Language Compiler integrierte Linker bindet den Maschinencode der angeforderten Libraries in den Maschinencode der zu übersetzenden Quelltextdateien ein.

Dynamic Link Option [-dll libname...]

Die Dynamic Link Option -lib erwartet den Namen einer oder mehrerer User Language-Libraries sowie die Spezifikation von zumindest einer Quellcodedatei (siehe oben, Option -Source). Die mit -dll angeforderten Libraries müssen in kompilierter Form in der Datei ulcprog.vdb im BAE-Programmverzeichnis verfügbar sein. Der im User Language Compiler integrierte Linker erzeugt die für den User Language Interpreter notwendigen Informationen zur Laufzeiteinbindung der angeforderten Libraries in den Maschinencode der zu übersetzenden Quelltextdateien.

Create Program/Library Option [{-cp|-cl} [dstname...]]

Mit dieser Option wird der Typ des zu erzeugenden Maschinencodes festgelegt. Der User Language Compiler kann sowohl User Language-Programme als auch User Language-Libraries generieren. Per standard, also wenn weder die Option -cp noch die Option -cl ist, erzeugt der Compiler User Language-Programme. Mit der Option -cp kann die Generierung von Programmen explizit veranlasst werden, die Option -cl hingegen veranlasst die Generierung von Libraries; es dürfen nicht beide Optionen gleichzeitig angegeben werden. Der Elementname des zu erzeugenden Maschinencodes ergibt sich standardmäßig aus dem jeweiligen Quellcodedateinamen durch Elimination des Verzeichnispfades und der Namenserweiterung. Abweichend von dieser Konvention können mit den Optionen -cp und -cl explizit andere Elementnamen für zu erzeugenden Maschinencode angegeben werden, wobei dann aber nur noch genau eine Quelltextdatei spezifiziert werden darf (siehe oben, Option -Source). Der generierte Maschinencode wird unter dem spezifizierten Zielelementnamen in der Datei ulcprog.vdb im BAE-Programmverzeichnis abgelegt. Wildcards werden bei der Angabe von Zielelementnamen für Maschinencode grundsätzlich nicht berücksichtigt. Die explizite Angabe mehrerer Zielelementnamen dagegen ist zulässig; damit ist es möglich den Maschinencode einer einzelnen Quelltextdatei unter verschiedenen Namen abzulegen, also z.B. aus der Quelltextdatei bae_st.ulh mit einem einzigen Compileraufruf die Programme scm_st, ged_st, usw. zu erzeugen.

Include Path Option [-I[nclude] includepath...]

Mit der Option -Include (bzw. -I) können Alternativpfade für die Suche nach Includedateien spezifiziert werden. Diese Option erwartet zumindest einen Verzeichnispfadnamen als Argument. Stößt der Compiler im Quelltext auf eine #include-Anweisung, dann sucht er zunächst im aktuellen Verzeichnis nach der angeforderten Includedatei und dehnt die Suche anschließend auf die mit der Option -Include angegebenen Verzeichnisse aus, wobei die Verzeichnisse in der Reihenfolge ihrer Spezifikation abgesucht werden.

Define Option [-D[efine] macroid...]

Mit der Option -Define (bzw. -D) können beim Compileraufruf Makros definiert werden. Diese Option erwartet zumindest einen Makronamen als Argument. Die Option -Define entspricht der #define-Anweisung im Quelltext, d.h. die mit dieser Option definierten Makros können in den Preprozessoranweisungen #ifdef und #ifndef zur Steuerung der bedingten Übersetzung ausgewertet werden.

Optimizer Option [-O[0|1]]

Mit der Option -O kann der Optimierer des User Language Compilers aktiviert bzw. deaktiviert werden. Per Default (d.h., wenn diese Option nicht spezifiziert ist) ist der Optimierer deaktiviert. Die Option -O bzw. -O1 aktiviert den Optimierer. Mit der Option -O0 kann der Optimierer explizit deaktiviert werden. Der Optimierer befreit den Maschinencode von Redundanzen, und gestaltet ihn durch Modifikationen effizienter. Optimierter Maschinencode benötigt in der Regel erheblich weniger Festplatten- und Hauptspeicher und kann schneller geladen und abgearbeitet werden. Es wird daher dringend empfohlen, den Optimierer zu aktivieren.

Error Severity Option [-e[0|1]]

Mit der Option -e kann der Error Severity Level gesetzt werden. Per default (d.h., wenn diese Option nicht spezifiziert ist) ist der Wert 1 eingestellt. Die Option -e0 setzt den Error Severity Level auf 0; die Option -e bzw. -e1 setzt den Error Severity Level explizit auf 1. Ist der Error Severity Level auf 1 eingestellt, dann versucht der Compiler alle beim Compileraufruf spezifizierten Quelltextdateien zu übersetzen (ungeachtet etwaiger Fehler beim übersetzen einzelner Quelltexte); ein Error Severity Level von 0 hingegen veranlasst den Compiler, den Übersetzungsvorgang bei der ersten fehlerhaften Quelltextdatei abzubrechen.

Warning Severity Option [-w[0|1|2|3|4]]

Mit der Option -w kann der Warning Severity Level auf einen Wert von 0 bis 4 gesetzt werden. Per Default (d.h., wenn diese Option nicht spezifiziert ist) ist der Wert 0 eingestellt. Wird diese Option ohne die explizite Angabe eines Levels angegeben (-w), dann wird der Wert 3 eingestellt. Jede im Compiler definierte Warnmeldung ist einem speziellen Warning Severity Level zugeordnet, wobei höhere Werte unwichtigere Warnungen kennzeichnen. Der Compiler gibt nur die Warnungen aus, deren Warning Severity Level kleiner oder gleich dem mit der Option -w eingestellten Level ist, d.h. mit dieser Option kann die Ausgabe weniger bedeutsamer Warnmeldungen unterdrückt werden.

Top Level Warnings Only Option [-t[0|1]]

Mit der Option -t können wahlweise Warnungen mit Bezug auf die Kompilierung von Includedateien unterdrückt werden (Wert 1). Per Default (d.h., wenn diese Option nicht spezifiziert ist bzw. der Optionswert 0 gesetzt ist) werden Warnmeldungen mit Bezug auf alle kompilierten Quellcodedateien ausgegeben. Ist dieser Optionswert auf 1 gesetzt, dann unterdrückt der User Language Compiler die Ausgabe von Warnmeldungen mit Bezug auf die Kompilierung von Includedateien und gibt lediglich die Warnmeldungen mit Bezug auf die "Top-Level"-Quellcodedatei(en) aus. Dies reduziert die Anzahl der Warnmeldungen und erleichtert damit deren Analyse insbesondere dann, wenn mit Standardincludedateien gearbeitet wird, die (eine Vielzahl von) Funktionen und Variablen enthalten, welche nicht in jedem Programm verwendet werden.

Listing Option [-l[0|1|2|3|4|5]]

Mit der Option -l kann die Listingausgabe gesteuert werden. Dabei können Listingmode im Bereich von 0 bis 5 spezifiziert werden. Mit dem Listingmodus 0 wird keine Listingausgabe erzeugt, während der Modus 5 die detailliertesten Informationen liefert. Modus 0 ist der Standardwert, d.h. wenn die Option -l nicht angegeben ist, dann erfolgt auch keine Listingausgabe. Wird diese Option ohne die explizite Angabe des Modus spezifiziert (-l), dann wird der Modus 5 eingestellt. Der Name der Listingdatei aus dem Namen der Quelltextdatei durch Abändern der Dateinamenserweiterung in .lst erzeugt. Die Listingdatei wird vom System nicht weiter benötigt, sie ist lediglich zur Auswertung durch den Benutzer bestimmt.

Listing Directory Option [-ld listingdirectory]

Die Option -ld gestattet die Spezifikation eines alternativen Verzeichnisses für die mit der Option -l auszugebenden Listindateien. Dies ist insbesondere bei der Verwendung von make-Utilities zur automatisierten Compilierung geänderter User Language-Programme nützlich, um das Quellverzeichnis "sauber" zu halten. Im Verzeichnis baeulc wird ein makefile bereitgestellt, das die Abhägigkeiten der User Language-Programme von Includedateien enthält und mit Listingdateien in einem Unterverzeichnis (lst) arbeitet.

Delete Program Option [-dp prgname...]

Mit der Option -dp können einmal übersetzte User Language-Programme wieder aus der Datei ulcprog.vdb im BAE-Programmverzeichnis gelöscht werden. Diese Option erwartet den Elementnamen zumindest eines Programms als Argument. Bei der Auswertung der Elementnamen werden Wildcards berücksichtigt, sofern die Wildcarderkennung mit der Option -wcon (siehe oben) aktiviert ist. Beim Versuch, nicht-existente Libraries zu löschen, werden Warnungen ausgegeben. Damit nicht Maschinencode gelöscht werden kann, der unmittelbar zuvor im gleichen Compiler-Lauf erzeugt wurde, erfolgt das Löschen von Programmen grundsätzlich immer bevor mit der Übersetzung von Quelltexten begonnen wird.

Delete Library Option [-dl libname...]

Mit der Option -dl können einmal übersetzte User Language-Libraries wieder aus der Datei ulcprog.vdb im BAE-Programmverzeichnis gelöscht werden. Diese Option erwartet den Elementnamen zumindest einer Library als Argument. Bei der Auswertung der Elementnamen werden Wildcards berücksichtigt, sofern die Wildcarderkennung mit der Option -wcon (siehe oben) aktiviert ist. Beim Versuch, nicht-existente Libraries zu löschen, werden Warnungen ausgegeben. Damit nicht Maschinencode gelöscht werden kann, der unmittelbar zuvor im gleichen Compiler-Lauf erzeugt wurde, erfolgt das Löschen von Libraries grundsätzlich immer bevor mit der Übersetzung von Quelltexten begonnen wird.

Program Database File Name Option [-ulp prgfilename]

Per Default speichert der User Language Compiler User Language-Programme in der Datei ulcprog.vdb im Programmverzeichnis des Bartels AutoEngineer ab. Mit der Option -ulp kann hierfür eine andere Datei angegeben werden.

Library Database File Name Option [-ull libfilename]

Per Default speichert der User Language Compiler User Language-Libraries in der Datei ulcprog.vdb im Programmverzeichnis des Bartels AutoEngineer ab. Mit der Option -ull kann hierfür eine andere Datei angegeben werden.

Log File Option [-log logfilename]

Der User Language Compiler gibt alle Meldungen auf die Standardausgabe und gleichzeitig auf eine Reportdatei aus. Die Ausgabe auf die Reportdatei erfolgt, um längere Listen von Meldungen, welche insbesondere bei der Übersetzung mehrerer Quelltextdateien entstehen können, zu sichern. Der Standardname der Reportdatei ist ulc.log (im aktuellen Verzeichnis). Mit der Option -log kann ein anderer Dateiname für die Reportdatei angegeben werden.

Beispiele

Kompilieren des in ulprog.ulc enthaltenen User Language-Programms mit Optimierung und Ausgabe von Warnmeldungen; das übersetzte Programm wird unter dem Namen ulprog in der Datei ulcprog.vdb im BAE-Programmverzeichnis abgelegt:

ulc ulprog -Ow

Kompilieren des in ulprog.ulc enthaltenen User Language-Programms mit Erzeugung einer Listingdatei (ulprog.lst); das übersetzte Programm wird unter dem Namen newprog in der Datei ulcprog.vdb im BAE-Programmverzeichnis abgelegt:

ulc ulprog -l -cp newprog

Löschen der User Language-Programme mit Namen ulprog und newprog sowie der User Language-Libraries, deren Namen mit test beginnen und auf lib enden, aus der Datei ulcprog.vdb im BAE-Programmverzeichnis:

ulc -dp ulprog newprog -dl test*lib

Erzeugen der User Language-Library libsll aus der Quelltextdatei libbae.ulh (der Optimierer ist aktiviert; ein Listing wird auf die Datei libbae.lst ausgegeben):

ulc libbae.ulh -cl libsll -l2O

Kompilieren aller im aktuellen Verzeichnis enthaltenen Quelltextdateien mit der Extension .ulc sowie statisches Linken der generierten Maschinenprogramme mit der User Language-Library libsll (das Makro USELIB wird zur Kontrolle der bedingten Übersetzung definiert; der Optimierer ist aktiviert):

ulc *.ulc -Define USELIB -lib libsll -O

Generieren der User Language-Libraries libstd und stdlib aus der Quelltextdatei std.ulh (der Optimierer ist aktiviert, Warnmeldungen mit Severity Level kleiner oder gleich 2 werden ausgegeben):

ulc -w2 -O -cl libstd stdlib -Source std.ulh

Generieren der User Language-Library liblay aus der Quelltextdatei \baeulc\lay.ulh mit dynamischen Linken der Library libstd (der Optimierer ist aktiviert, der Warning Severity Level ist auf den Standardwert 3 gesetzt, die Compiler-Meldungen werden auf die Reportdatei genlib.rep anstelle ulc.log ausgegeben):

ulc /wO -cl liblay -S \baeulc\lay.ulh -dll libstd -log genlib.rep

Generieren der User Language-Programme laypcr und tracerep aus den Quelltextdateien laypcr.old und tracerep.ulc mit dynamischem Linken der Library liblay (der Optimierer ist aktiviert):

ulc laypcr.old /dll liblay /cp -O /S tracerep

3.2.3 Fehlerbehandlung

Mit der wichtigste Bestandteil des Compilers ist die Fehlerbehandlung. Dies ist darin begründet, dass der Compiler am weitaus häufigsten Quellcodedateien zu bearbeiten hat, die fehlerbehaftet sind oder Redundanzen aufweisen (ein absolut fehlerfreies Programm wird i.d.R. nur einmal übersetzt). Die durch den Compiler ausgegebenen Fehlermeldungen sollen dem Programmierer helfen, das zu entwickelnde Programm bzw. die zu erzeugende Library möglichst schnell in einen fehlerfreien Zustand zu bringen.

Der User Language Compiler gibt alle Meldungen auf die Standardausgabe und gleichzeitig auf eine Reportdatei aus. Die Ausgabe auf die Reportdatei erfolgt, da die Liste der Meldungen - insbesondere bei der Übersetzung mehrerer Quellcodedateien - sehr umfangreich werden kann. Der Standardname ulc.log der Reportdatei kann mit der Compiler-Option -log geändert werden.

Im Folgenden ist eine Liste aller im User Language Compiler definierten Meldungen, Warnungen und Fehler aufgeführt. Beim Auftreten von Fehlern kann kein ablauffähiger Maschinencode erzeugt werden. Warnungen weisen den Programmierer darauf hin, dass zwar ablauffähiger Maschinen-Code erzeugt werden kann, dieser aber u.U. mit unerwünschten Nebeneffekten behaftet ist. Wo immer möglich, wird der Meldung in Klammern die Zeilennummer vorangestellt, in der der Fehler lokalisiert wurde; diese Zeilennummer bezieht sich entweder auf die Quellcode-Datei (Ll) oder auf den Maschinen-Code (Lp).

Den unten aufgeführten Warnmeldungen ist jeweils eine Nummer in eckigen Klammern vorangestellt. Diese Angaben sind nicht Bestandteil der tatsächlich ausgegebenen Warnungen, sondern geben vielmehr den Warning Severity Level an, der mit der Option -w mindestens eingestellt sein muss, damit die entsprechende Warnung vom User Language Compiler ausgegeben wird. Warnungen, die dem Severity Level 0 zugeordnet sind, werden unabhängig vom aktuell eingestellten Warning Severity Level grundsätzlich ausgegeben.

Allgemeine Meldungen

Bei einem syntaktisch falschen Aufruf des User Language Compilers korrekten Aufrufsyntax des Compilers angezeigt, und der Compiler-Lauf wird abgebrochen.

Die folgenden allgemeinen Compiler-Meldungen geben Aufschluss über die Aktionen des Compilers bzw. werden als resümierende Meldungen über den Compiler-Lauf ausgegeben:

Loeschen Programme aus "n"...
Programm 'n' geloescht.
Loeschen Libraries aus "n"...
Library 'n' geloescht.
Libraries Laden/Linken...
Quellcodedatei "n" wird kompiliert...
Programm 'n' erfolgreich generiert.
Library 'n' erfolgreich generiert.
Quellcodedatei "n" erfolgreich kompiliert.
e Fehler, w Warnungen.
User Language Compiler-Lauf abgebrochen!
User Language Compiler-Lauf erfolgreich beendet.

Die folgenden Fehlermeldungen stehen in direktem Zusammenhang und weisen auf fehlende Benutzungsberechtigung zur Ausführung des User Language Compilers, ungültige Datei- bzw. Elementnamensangaben, Dateizugriffsprobleme oder Probleme beim Zugriff auf User Language-Libraries hin:

FEHLER : Die Benutzungsberechtigung fehlt!
FEHLER : Dateiname "n" ist zu lang!
FEHLER : Dateiname "n" enthaelt ungueltige Zeichen!
FEHLER : Elementname 'n' ist zu lang!
FEHLER : Elementname 'n' enthaelt ungueltige Zeichen!
FEHLER : Fehler beim Schreiben auf Listing-Datei "n"!
FEHLER : ULC-Log-Datei "n" kann nicht angelegt werden!
FEHLER : Zu viele Quellcodedateien spezifiziert!
FEHLER : Quellcodedatei "n" nicht gefunden!
FEHLER : Library 'n' nicht gefunden"!
FEHLER : User Language Library 'n' Version inkompatibel!

Die folgenden Warnmeldungen stehen in direktem Zusammenhang mit dem Compileraufruf und weisen auf Probleme beim Lesen von Verzeichnissen bzw. beim Zugriff auf Programme oder Libraries, sowie auf Kompatibilitätsprobleme beim Linken von Libraries hin:

[0] WARNUNG : Verzeichnis 'n' nicht gefunden/nicht verfuegbar!
[0] WARNUNG : Programm 'n' nicht gefunden!
[0] WARNUNG : Library 'n' nicht gefunden!
[0] WARNUNG : User Language Library 'n' nicht optimiert!

Interne Compiler-Fehler

Die folgenden internen Compiler-Fehler können in Zusammenhang mit der Speicherverwaltung stehen oder auf Implementierungs-Lücken im Compiler hinweisen:

(Ll) FEHLER : Listen-Ueberlauf!
(Ll) FEHLER : Zu wenig Speicherplatz!
(Ll) FEHLER : INTERNER FEHLER IN function -- BITTE MELDEN!

Parser Fehler

Die folgenden Fehler können beim Zugriff auf Quelltextdateien bzw. bei der Syntaxanalyse auftreten:

(Ll) FEHLER : Eingabedatei "n" nicht gefunden!
(Ll) FEHLER : Eingabedatei "n" kann nicht gelesen werden!
(Ll) FEHLER : Eingabedatei Dateielement zu lang ('s')!
(Ll) FEHLER : Eingabedatei Ausdruck zu komplex ('s')!
(Ll) FEHLER : Syntaxfehler bei 'string' (unerwartetes Symbol)!
(Ll) FEHLER : Allgemeiner Analyser-Fehler!

Semantische Fehler und Warnungen

Die folgenden Fehler können bei der semantischen Prüfung der Quelltextdatei auftreten:

(Ll) FEHLER : Identifier 'n' ist zu lang!
(Ll) FEHLER : Character 's' ist zu lang / Kein Character!
(Ll) FEHLER : String 's' ist zu lang!
(Ll) FEHLER : Numerische Angabe 's' ist zu lang!
(Ll) FEHLER : Ungueltige numerische Angabe 's'!
(Ll) FEHLER : Typ 'n' nicht definiert!
(Ll) FEHLER : Typ 'n' mehrfach definiert!
(Ll) FEHLER : Funktion 'n' undefiniert!
(Ll) FEHLER : Funktion 'n' mehrfach definiert!
(Ll) FEHLER : Funktion 'n' ist als System-Funktion definiert!
(Ll) FEHLER : Funktions-Parameter 'n' nicht definiert!
(Ll) FEHLER : Funktions-Parameter 'n' mehrfach definiert!
(Ll) FEHLER : Funktions-Parameter 'n' mehrfach deklariert!
(Ll) FEHLER : Variable 'n' nicht definiert!
(Ll) FEHLER : Variable 'n' mehrfach definiert!
(Ll) FEHLER : Zuweisung an Konstante oder Ergebnis nicht erlaubt!
(Ll) FEHLER : Kein Array; Index-Zugriff nicht moeglich!
(Ll) FEHLER : Ungueltige Array-Index-Angabe!
(Ll) FEHLER : Array-Index nicht im gueltigen Bereich!
(Ll) FEHLER : Zugriff auf Element ('n') aus unbekannter Struktur!
(Ll) FEHLER : Struktur 'n' unbekannt/ungueltig!
(Ll) FEHLER : Struktur 'n' mehrfach definiert!
(Ll) FEHLER : Struktur-Element 'n' unbekannt/ungueltig!
(Ll) FEHLER : Struktur-Element 'n' mehrfach definiert!
(Ll) FEHLER : Index 'n' unbekannt/ungueltig!
(Ll) FEHLER : Index-Variable 'n' unbekannt/ungueltig!
(Ll) FEHLER : 'n' ist keine Variable vom Typ index!
(Ll) FEHLER : 'forall'-Index nicht in 'of'-Index 'n' enthalten!
(Ll) FEHLER : 'continue' nicht innerhalb Schleife!
(Ll) FEHLER : 'break' nicht innerhalb Schleife oder 'switch'!
(Ll) FEHLER : 'void'-Funktion 'n' kann keinen 'return'-Wert liefern!
(Ll) FEHLER : Funktion 'n' muss gueltigen 'return'-Wert liefern!
(Ll) FEHLER : 'return'-Ausdruck nicht typ-kompatibel zur Funktion 'n'!
(Ll) FEHLER : Ausdruck nicht typ-kompatibel zum Parameter 'n'!
(Ll) FEHLER : Ausdruck nicht typ-kompatibel zur Variablen 'n'!
(Ll) FEHLER : Operand nicht typ-kompatibel zum 'n'-Operator!
(Ll) FEHLER : Operanden nicht typ-kompatibel zum 'n'-Operator!
(Ll) FEHLER : Zuweisung an aktiven Schleifen-Index unzulaessig!
(Ll) FEHLER : Ungueltiger 'n'-Ausdruck!
(Ll) FEHLER : Unbekannte/undefinierte Funktion 'n'!
(Ll) FEHLER : Funktion 'n' - zu wenig Parameter spezifiziert!
(Ll) FEHLER : Funktion 'n' - Parameter nicht kompatibel!
(Ll) FEHLER : Funktion 'n' - Parameter nicht im Wertebereich!
(Ll) FEHLER : Ungueltige '#if-#else-#endif'-Konstruktion!
(Ll) FEHLER : Identifier 'n' ist als Makro definiert!
(Ll) FEHLER : Zugriff auf void Makro 'n'!
(Ll) FEHLER : BNF kann nicht in UL-Library gespeichert werden!
(Ll) FEHLER : BNF mehrfach definiert!
(Ll) FEHLER : BNF-Symbol 'n' unbekannt/undefiniert!
(Ll) FEHLER : BNF-Produktion 'n' mehrfach definiert!
(Ll) FEHLER : BNF-Reduce/Reduce-Konflikt bei Produktion 'n'!
(Ll) FEHLER : BNF-Terminalsymbol 'n' ist ungueltig!
(Ll) FEHLER : BNF-Kommentarbegrenzer 's' ist ungueltig!
(Ll) FEHLER : BNF-Funktion 'n' ist nicht vom Type 'int'!
(Ll) FEHLER : Division durch Null!
(Ll) FEHLER : Endlos-Schleife!
(Ll) FEHLER : Funktion 'n' - rekursiver Aufruf!
(Lp) FEHLER : Stack Ueberlauf!
FEHLER : Dateiende erreicht; '}' wurde erwartet!
FEHLER : Inkompatible Index-/Funktions-Referenz(en)!

Die folgenden Warnungen können bei der semantischen Prüfung der Quellcodedatei auftreten:

[1] (Ll) WARNUNG : BNF enthaelt keine gueltigen Produktionen!
[2] (Ll) WARNUNG : Funktion 'n' - Default-'return'-Wert verwendet!
[1] (Ll) WARNUNG : Funktion 'n' - zu viele Parameter spezifiziert!
[2] (Ll) WARNUNG : Funktion 'n' - Aenderung n. Parameter wird ignoriert!
[2] (Ll) WARNUNG : Funktion 'n' - Aenderung fuer Parameter 'n' wird ignoriert!
[2] (Ll) WARNUNG : Konstanter 'n'-Ausdruck!
[2] (Ll) WARNUNG : Ausdruck hat keine Seiten-Effekte!
[2] (Ll) WARNUNG : Funktion 'n', lokale Variable 'n' verdeckt globale Variable!
[2] (Ll) WARNUNG : Funktion 'n', Parameter 'n' verdeckt globale Variable!
[4] (Ll) WARNUNG : Variable 'n' wurde nicht initialisiert!
[4] (Ll) WARNUNG : Makro 'n' neu definiert!

Optimierer-Warnungen

Die folgenden Warnungen werden ggf. vom Optimierer erzeugt und weisen auf Redundanzen im Quellcode hin:

[1] (Ll) WARNUNG : BNF ist nicht referenziert!
[2] (Ll) WARNUNG : Globale Variable 'n' ist nicht referenziert!
[2] (Ll) WARNUNG : Funktion 'n' ist nicht referenziert!
[2] (Ll) WARNUNG : Statement wird nicht erreicht!
[3] (Ll) WARNUNG : Funktion 'n', Lokale Variable 'n' ist nicht referenziert!
[3] (Ll) WARNUNG : Funktion 'n', Parameter 'n' ist nicht referenziert!
[4] WARNUNG : Library-Funktion 'n' ist nicht referenziert!
[4] WARNUNG : Library-Variable 'n' ist nicht referenziert!
[4] WARNUNG : Dynamic Link Library 'n' ist nicht referenziert!

Datenbank-Zugriffs-Fehler

Die folgenden Fehler können beim Speichern des Maschinen-Codes auftreten:

FEHLER : Datenbankdatei "n" kann nicht angelegt werden!
FEHLER : Schreib-/Lesefehler beim Zugriff auf Datei "n"!
FEHLER : Zu viele offene Dateien im System!
FEHLER : Datei "n" ist keine Datenbank/DDB-Datei!
FEHLER : Die Datenbankstruktur in Datei "n" ist beschaedigt!
FEHLER : Der Dateiaufbau ist fehlerhaft in Datei "n"!
FEHLER : Funktion fuer altes Format nicht verfuegbar!
FEHLER : Datenbank Limit ueberschritten!
FEHLER : Datei "n" ist zur Programmversion inkompatibel!
FEHLER : Element 'n' nicht gefunden!
FEHLER : Element 'n' existiert bereits!
FEHLER : Datei "n" nicht gefunden!
FEHLER : Record-Ende erreicht!
FEHLER : Allgemeiner Datenbankfehler!

3.3 Interpreter

Der Bartels User Language Interpreter ist in verschiedenen Programmumgebungen integriert. Im Bartels AutoEngineer sind dies der Schaltplaneditor, der Layouteditor, der Autorouter, der CAM-Prozessor, das CAM-View-Modul sowie der Chipeditor. Aus all diesen Programmteilen können mit Hilfe des User Language Interpreter User Language-Programme gestartet werden.

3.3.1 Arbeitsweise

Die Aktivierung des User Language Interpreter erfolgt durch den Aufruf eines User Language-Programms aus einer der gültigen Interpreterumgebungen. Die Abarbeitung eines User Language-Programmaufrufs durch den User Language Interpreter erfolgt in den nachfolgend beschriebenen Arbeitsschritten.

Programm laden, Dynamic Link

Zunächst muss der User Language Interpreter das User Language-Maschinenprogramm über den beim Aufruf spezifizierten Programmnamen aus der Datei ulcprog.vdb (im BAE-Programmverzeichnis) laden (Program Load). Beim Laden des Maschinenprogramms führt der Interpreter eine Kompatibilitätsprüfung durch; eine Konsistenzprüfung ist hierbei nicht mehr nötig, da diese zeitaufwändige Arbeit bereits durch den Compiler erledigt wurde. Ein zu ladendes User Language-Programm gilt in der aktuellen Interpreterumgebung als kompatibel und damit ablauffähig, wenn die User Language Compiler-Version, mit der das Programm erzeugt wurde, identisch mit der des User Language Interpreter ist, und wenn das Programm keine Referenzen auf Index-Variablen-Typen oder Systemfunktionen enthält, die in der aktuellen Interpreterumgebung nicht implementiert sind.

User Language-Programme können Anforderungen zur Laufzeiteinbindung von User Language-Libraries enthalten (Dynamic Link Requests). Die Einbindung des Maschinencodes der benötigten Dynamic Link Libraries (DLLs) erfolgt automatisch während der Programmladephase. Grundvoraussetzung für die erfolgreiche Durchführung des Dynamic-Link-Prozesses ist die Verfügbarkeit der benötigten Libraries. Außerdem müssen die im Maschinencode der einzubindenden Dynamic Link Libraries enthaltenen Definitionen (Variablen, Funktionen, Funktionsparameter) mit dem bei der Kompilierung durch den User Language Compiler überprüften Maschinencode übereinstimmen, damit bei der Ausführung des Programms nicht etwa fehlende oder falsche Libraryobjekte referenziert werden können (was zu einem undefinierten Verhalten des User Language Interpreter oder sogar zum Programmabsturz mit möglichem Datenverlust führen könnte). Der im User Language Interpreter integrierte Linker führt entsprechende Kompatibilitätsprüfungen durch und verweigert im Falle von Inkonsistenzen die Programmausführung mit der Fehlermeldung Inkompatible Index-/Funktions-Referenz(en)!. In solchen Fällen ist das auszuführende User Language-Programm neu zu kompilieren.

Programmausführung

Nachdem das User Language-Maschinenprogramm geladen (und dynamisch gelinkt) ist, beginnt der Interpreter mit der Ausführung des Programms (Program Execute). Die Programmausführung entspricht dabei der Simulation der User Language-Maschinenarchitektur durch Abarbeitung der Instruktionen des Maschinenprogramms. Die Abarbeitung beginnt bei der ersten Instruktion des Maschinenprogramms und ist beendet, wenn der Programmzähler auf eine nicht mehr existente Instruktion des Maschinenprogramms verweist.

Programmterminierung

Nach der Ausführung des Maschinenprogramms muss eine Terminierung durchgeführt werden. Dabei wird zunächst der während des Programmlaufs belegte Speicher wieder freigegeben (Program Cleanup), und anschließend wird das Programm selbst entladen (Program Unload).

3.3.2 Programmaufruf

Beim Aufruf eines User Language-Programms aus einer der definierten Interpreterumgebungen ist in jedem Fall der Name des auszuführenden Programms zu spezifizieren. Dies kann entsprechend den nachfolgend beschriebenen Methoden entweder explizit oder implizit erfolgen.

Aufruf über Menü

Zum expliziten Aufruf von User Language-Programmen ist die Funktion Anwenderfunktion aus dem Menü Datei zu benutzen. Anwenderfunktion aktiviert einen Dialog zur Programmnamensabfrage. Der Programmname kann entweder direkt über Tastatur eingegeben oder nach Anwahl der Schaltfläche Liste aus der Liste der aktuell verfügbaren Programme selektiert werden:

Datei

Anwenderfunktion

Programmname ?

programname

Wird auf die Abfrage nach dem Programmnamen ein Fragezeichen (?) eingegeben oder eine Maustaste aktiviert, dann zeigt das System ein Popupmenü mit den Namen aller aktuell in ulcprog.vdb verfügbaren User Language-Programme an; hieraus kann das zu startende Programm über Mauspick selektiert werden.

Aufruf über Tastatur

Eine Möglichkeit des impliziten Programmaufrufs besteht durch den Programmaufruf über die Tastatur. Hierzu muss sich der Anwender in der Menüleiste der Interpreterumgebung befinden, d.h. diese Art des Programmaufrufs ist immer dann möglich, wenn nicht gerade eine andere interaktive Eingabe über Tastatur erwartet wird. Die Spezifikation des Programmnamens erfolgt dabei implizit durch Drücken einer speziellen Taste. Tabelle 3-2 enthält die Liste der definierten Zuordnung von Tasten zu User Language-Programmnamen innerhalb der unterschiedlichen Interpreterumgebungen. Durch Drücken einer der in dieser Tabelle angegebenen Tasten wird - sofern verfügbar - automatisch das entsprechend benannte User Language-Programm gestartet. Mit bae_* benannte Programme haben dabei Priorität vor den Programmen mit modulspezifischen Namen.

Tabelle 3-2: Tastaturgesteuerter Programmaufruf

Ereignisgesteuerter Programmaufruf

Eine spezielle Möglichkeit des impliziten Programmaufrufs besteht im ereignisgesteuerten Aufruf von User Language-Programmen. Dabei lösen spezielle Ereignisse bzw. Operationen (BAE-Modulstart, Laden bzw. Speichern eines Elements, Ändern des Zoomfaktors oder Selektion eines Toolbarelements) automatisch den Aufruf von User Language-Programmen mit definiertem Namen aus. Tabelle 3-3 enthält die Zuordnung der vordefinierten User Language-Programmnamen zu den entsprechenden Ereignissen bzw. Operationen der einzelnen Interpreterumgebungen. Mit bae_* benannte Programme haben dabei Priorität vor den Programmen mit modulspezifischen Namen. Der Aufruf über die Startupsequenz der Interpreterumgebung eignet sich besonders zur automatischen Voreinstellung von Parametern sowie zur Tastaturprogrammierung und Menübelegung (siehe auch unten). Der implizite Aufruf von User Language-Programmen nach dem Laden bzw. vor dem Speichern von Elementen ermöglicht die automatische Aktivierung elementspezifischer Bearbeitungsparameter wie z.B. des zuletzt selektierten Zoombereichs oder spezieller Farbeinstellungen.

Tabelle 3-3: Ereignisgesteuerter Programmaufruf

Tastaturprogrammierung und Menübelegung

Mit der Bartels User Language werden Systemfunktionen zur Tastaturprogrammierung und Menübelegung zur Verfügung gestellt. Damit ist es möglich, User Language-Programmaufrufe oder BAE-Menüfunktionen auf die Tastatur zu legen (z.B. Taste m zur Aktivierung des User Language-Programms mirron oder Taste U zur Aktivierung der BAE-Menüfunktion Undo). Durch die Zuweisung spezieller User Language-Programmaufrufe oder Menüfunktionen auf neue bzw. bestehende Menüs oder Menüeinträge können die Menüoberflächen der AutoEngineer-Module mit integriertem User Language Interpreter nach Belieben konfiguriert werden. Die Tastaturprogrammierung bzw. die Menübelegung lässt sich vollautomatisch über die jeweiligen User Language-Startupprogramme durchführen (siehe hierzu das mit der BAE-Software ausgelieferte User Language-Programm uifsetup welches indirekt über die in Tabelle 3-3 aufgeführten Startupprogramme aufgerufen wird). Mit einem geeigneten User Language-Programm ist sogar die dynamische Änderung der Tastatur- und Menübelegung (d.h. online während der Arbeit im AutoEngineer) möglich. Derartige Features sind z.B. in dem mit der BAE-Software ausgelieferten User Language-Programm keyprog implementiert. Damit besteht völlige Freiheit bei der Konfiguration der Benutzeroberflächen der AutoEngineer-Module mit integriertem User Language Interpreter.

Menüfunktionstastenbelegung

In BAE-Pulldownmenüoberflächen unterstützt das über Taste 5 aufrufbare User Language-Programm keyprog die direkte Zuweisung von Menüfunktionen zu Tasten. Dazu ist nach Selektion der zu programmierenden Taste über Tastaturprogrammierung und HotKeys belegen und Anklicken der Schaltfläche Menuauswahl im Programmauswahlmenü einfach die gewünschte Menüfunktion zu selektieren.

Definition von Bearbeitungssequenzen (Makros)

Über Anwenderfunktion, in User Language-Programmaufrufen über die Funktion ulsystem, bei der Definition von Tasten und Menüfunktionen in der Datei bae.ini sowie bei der Online-Tastenprogrammierung mit dem User Language-Programm keyprog kann anstatt eines einfachen User Language-Programmnamens eine komplette Bearbeitungssequenz angegeben werden. Die einzelnen Bearbeitungsschritte sind durch das Zeichen : zu trennen. Ein User Language-Programmname, der nicht am Anfang der Bearbeitungssequenz steht, ist durch ein vorangestelltes p zu kennzeichnen. Ein vorangestelltes # referenziert direkt eine interne BAE-Funktion entsprechend dem Aufruf von bae_callmenu. In einfachen Anführungszeichen gesetzte Texte werden als Texteingaben übernommen. Mit t wird auf die Eingabe eines Textes durch den Benutzer gewartet. s wartet auf eine Menuselektion, gefolgt von l, m oder r und einem Menüindex (Start der Zählung bei 0) wird eine Menuselektion entsprechend dem Aufruf von bae_storemenuiact durchgeführt. Ein alleinstehendes m wartet auf einen Mausklick. Folgt darauf ein l, m oder r, dann wird ein Mausklick mit der entsprechenden Maustaste an der zu Beginn der Bearbeitungssequenz ermittelteten Mausposition durchgeführt. Folgen der Maustaste noch durch Komma getrennte Koordinatenangaben, so wird die Maustaste an der angegebenen Position aktiviert.

Damit ist es möglich, Untermenüpunkte, wie z.B. Symbol/Label Query (Bearbeitungssequenz scmpart:s5:m:t:mr) direkt auf Tasten zu legen. Auch ganze Abfolgen von immer wiederkehrenden Arbeitsschritten sind möglich. So wird z.B. im Schaltplaneditor mit der Sequenz #500:ml:mr:sl3:'4':'0':mr:sl0 von der aktuellen Mausposition aus ein waagerechtes 4mm langes Stück Grafiklinie nach rechts gezeichnet, wie man es immer wieder bei der Bearbeitung von Symbolen zur grafischen Anbindung von Pins an eine Symbolbox benötigt.

Benutzerspezifische Programmeinstellungen und Menükonfiguration

Zur vereinfachten Handhabung von benutzerspezifischen Einstellungen können Parameterdefinitionen, Tastaturbelegungen und Menüerweiterungen in die Datei bae.ini im BAE-Programmverzeichnis eingetragen werden. Die Definitionen aus dieser Datei werden einmalig beim BAE-Programmstart in den Speicher geladen und können anschließend mit der User Language-Systemfunktion varget abgefragt werden.

Die mit der BAE-Software ausgelieferten User Language-Programme berücksichtigen relevante Definitionen und Parametereinstellungen aus bae.ini. Zur Aktivierung von Änderungen in bae.ini ist somit lediglich ein Neustart des von den Änderungen betroffenen BAE-Programmmoduls erforderlich. Benutzerspezifische Parametereinstellungen können damit komfortabel zwischen verschiedenen BAE-Versionen bzw. BAE-Installationen ausgetauscht werden.

Die Datei bae.ini ist in Sektionen für die einzelnen BAE-Module unterteilt. Beim Modulstart werden nur die Einstellungen des aktiven Moduls berücksichtigt. Die Definitionen aus der Sektion std gelten für alle Module.

Neben einfachen Parameterzuweisungen können mit den Schlüsselwörtern key und fkey Standard- und Funktionstasten mit Bearbeitungssequenzen belegt werden. Die Schlüsselwörter addmenu, addmenuitem, addsmenuitem und addioitem erlauben die Erweiterung der Menüstruktur. Es können jeweils nur Menüpunkte an das Ende eines Hauptmenüs oder des Import/Export-Menüs angehängt werden. Ein Einfügen von Menüpunkten in Menüs ist nicht möglich, da dadurch die Topic-Zuweisung für die Online-Hilfe durcheinander geraten würde.

Die Syntax der einzelnen Kommandos ist aus der Inlinedokumentation der mitgelieferten Datei bae.ini zu ersehen. In ihrer Originalversion definiert diese Datei die Parametereinstellungen aus den mit der BAE-Software ausgelieferten User Language-Programmen, also die Standardeinstellungen, die auch dann verwendet werden, wenn die Datei bae.ini beim BAE-Programmaufruf nicht im BAE-Programmverzeichnis verfügbar ist.

3.3.3 Fehlerbehandlung

Während der Bearbeitung eines User Language-Programmaufrufs durch den User Language Interpreter können Fehler auftreten. Diese Fehler werden der Interpreterumgebung zurückgemeldet, und es wird ggf. eine entsprechende Fehlermeldung in der Mitteilungszeile der Interpreterumgebung angezeigt. Die möglichen Fehlermeldungen sind nachfolgend aufgelistet.

Interne Interpreter-Fehler

Die folgenden internen Interpreter-Fehler beziehen sich entweder auf die Speicherverwaltung oder weisen auf Implementierungslücken im Interpreter selbst hin; diese Fehler sind so schwerwiegend (Fatal Errors), dass auch die Interpreterumgebung abgebrochen werden muss:

FEHLER : Zu wenig Speicherplatz!
FEHLER : Allgemeiner User Language-Interpreter-Fehler!
FEHLER : INTERNER FEHLER -- BITTE MELDEN!

Programm-Lade-Fehler

Die folgenden Fehler können beim Laden des User Language-Programms auftreten:

FEHLER : Programm 'n' bereits geladen (rekursiver Aufruf)!
FEHLER : Programm 'n' nicht gefunden!
FEHLER : User Language-Programm-Version inkompatibel!
FEHLER : Inkompatible Index-/Funktions-Referenz(en)!

Programm-Laufzeit-Fehler

Die folgenden Fehler können während der Ausführung des User Language-Programms, d.h. zur Laufzeit des Programms auftreten; der in der Fehlermeldung angezeigte Programmzähler (PCl) gibt dabei die Zeile im User Language-Maschinenprogramm an, in der der Fehler aufgetreten ist (sofern durch den User Language Compiler eine entsprechende Listing-Datei für das betreffende Programm erzeugt wurde, lässt sich mit deren Hilfe die entsprechende Zeile im Quellcode ermitteln):

(PCl) FEHLER : Stack Unterlauf (Programm-Struktur beschaedigt)!
(PCl) FEHLER : Stack Ueberlauf!
(PCl) FEHLER : Division durch Null!
(PCl) FEHLER : Funktions-Aufruf fehlgeschlagen!
(PCl) FEHLER : System-Funktion in dieser Umgebung nicht verfuegbar!
(PCl) FEHLER : System-Funktion nicht implementiert!
(PCl) FEHLER : User-Funktion nicht gefunden!
(PCl) FEHLER : Referenzierte Funktion ist vom falschen Typ!
(PCl) FEHLER : Ungueltige Parameter fuer referenzierte Funktion!
(PCl) FEHLER : Fehler beim Zugriff auf Array!
(PCl) FEHLER : Ungueltiger Array-Index!
(PCl) FEHLER : Datei-Zugriffs-Fehler!
(PCl) FEHLER : Datei-Lese-Fehler!
(PCl) FEHLER : Datei-Schreib-Fehler!

Datenbank-Zugriffs-Fehler

Die folgenden Fehler können beim Zugriff auf die Design Datenbank (DDB) des Bartels AutoEngineer auftreten; treten derartige Fehler beim Laden von User Language-Programmen auf, dann liegt unter Umständen eine fehlerhafte Installation der Bartels AutoEngineer Software vor; treten Datenbank-Zugriffsverletzungen hingegen während der Programmlaufzeit auf, dann bezieht sich die entsprechende Fehlermeldung in aller Regel auf Implementierungs-Fehler im abzuarbeitenden User Language-Programm:

FEHLER : Datenbankdatei 'n' kann nicht angelegt werden!
FEHLER : Schreib-/Lesefehler beim Zugriff auf Datei 'n'!
FEHLER : Zu viele offene Dateien im System!
FEHLER : Datei 'n' ist keine Datenbank/DDB-Datei!
FEHLER : Die Datenbankstruktur in Datei 'n' ist beschaedigt!
FEHLER : Der Dateiaufbau ist fehlerhaft in Datei 'n'!
FEHLER : Funktion fuer altes Format nicht verfuegbar!
FEHLER : Datenbank Limit ueberschritten!
FEHLER : Datei 'n' ist zur Programmversion inkompatibel!
FEHLER : Element 'n' nicht gefunden!
FEHLER : Element 'n' existiert bereits!
FEHLER : Datei 'n' nicht gefunden!
FEHLER : Record-Ende erreicht!
FEHLER : Allgemeiner Datenbankfehler!

4 BAE User Language-Programme

Inhalt

4.1.1

Standard-Includedateien

4.1.2

SCM-Includedateien

4.1.3

Layout-Includedateien

4.1.4

IC-Design-Includedateien

4.2.1

Standard-Programme

4.2.2

SCM-Programme

4.2.3

Layout-Programme

4.2.4

GED-Programme

4.2.5

Autorouter-Programme

4.2.6

CAM-Prozessor-Programme

4.2.7

CAM-View-Programme

4.2.8

IC-Design-Programme

4.2.9

CED-Programme

4.3.1

Kompilierung

4.3.2

Menübelegung und Tastaturprogrammierung

4.1 User Language-Includedateien

Die in diesem Abschnitt aufgeführten User Language-Programmdateien sind Includedateien, die häufig benötigte Definitionen und Funktionen enthalten. Diese Include-Files werden von den mit der BAE-Software ausgelieferten User Language-Programmen extensiv referenziert.

4.1.1 Standard-Includedateien

std.ulh (STD) -- Standard-Include

Die Definitionen und Deklarationen aus der Includedatei std.ulh sind kompatibel zu allen Interpreterumgebungen des Bartels AutoEngineer (also sowohl zum Schaltplaneditor, als auch zum Layouteditor, zum Autorouter, zum CAM-Prozessor, zum CAM-View-Modul und zum Chipeditor). std.ulh enthält neben häufig benötigten Konstanten unter anderem auch Funktionen zur Bilddarstellung und Datenkonvertierung, Routinen für das Fehlermeldewesen und zur Internationalisierung sowie BAE-Menüfunktionen und Utilities zur Abfrage der BAE-Softwarekonfiguration und zur Manipulation des Arbeitsbereichs.

baeparam.ulh (STD) -- BAE-Parameterzugriff

Die Definitionen und Deklarationen aus der Includedatei baeparam.ulh sind kompatibel zu allen Interpreterumgebungen des Bartels AutoEngineer. baeparam.ulh enthält Funktionen für den Zugriff auf System- und Bearbeitungsparameter. In die Datei baeparam.ulh ist über Include-Anweisung die Quellcodedatei std.ulh (siehe oben) eingebunden.

pop.ulh (STD) -- Popup-Utilities

Die Definitionen und Deklarationen aus der Includedatei pop.ulh sind kompatibel zu allen Interpreterumgebungen des Bartels AutoEngineer. In pop.ulh sind Routinen zur menügesteuerten Datei- und Elementnamensabfrage, allgemeine Popupfunktionen, Funktionen zum Auflisten von Verzeichnisinhalten sowie BAE-Menüfunktionen und Utilities zur Abfrage der BAE-Softwarekonfiguration definiert. In die Datei pop.ulh ist über Include-Anweisung die Quellcodedatei std.ulh (siehe oben) eingebunden.

popdraw.ulh (STD) -- Popup-Zeichenfunktionen

Die Definitionen und Deklarationen aus der Includedatei popdraw.ulh sind kompatibel zu allen Interpreterumgebungen des Bartels AutoEngineer. popdraw.ulh enthält allgemeine Utilities und Definitionen zur Anzeige von Icons und Buttons sowie zur Grafikausgabe in Popupmenüs. In die Datei popdraw.ulh ist über Include-Anweisung die Quellcodedatei std.ulh (siehe oben) eingebunden.

mnu.ulh (STD) -- Menüfunktionen

Die Definitionen und Deklarationen aus der Includedatei mnu.ulh sind kompatibel zu allen Interpreterumgebungen des Bartels AutoEngineer. mnu.ulh enthält erweiterte Popup- und Menü-Utilities zur Textanzeige, zur Textabfrage, zur Farbauswahl, zur Anzeige von BAE-Produktinformationen, usw. In die Datei mnu.ulh ist über Include-Anweisung die Quellcodedatei pop.ulh (siehe oben) eingebunden.

sql.ulh (STD) -- SQL-Utilities

Die Definitionen und Deklarationen aus der Includedatei sql.ulh sind kompatibel zu allen Interpreterumgebungen des Bartels AutoEngineer. sql.ulh enthält eine Reihe nützlicher Routinen für die Verwaltung von relationalen SQL-Datenbanken sowie den Zugriff auf deren Inhalt. In die Datei sql.ulh ist über Include-Anweisung die Quellcodedatei pop.ulh (siehe oben) eingebunden.

xml.ulh (STD) -- XML-Utilities

Die Definitionen und Deklarationen aus der Includedatei xml.ulh sind kompatibel zu allen Interpreterumgebungen des Bartels AutoEngineer. xml.ulh enthält eine Reihe nützlicher Import- und Export-Funktionen fuer XML-Dateien. In die Datei xml.ulh ist über Include-Anweisung die Quellcodedatei std.ulh (siehe oben) eingebunden.

4.1.2 SCM-Includedateien

scm.ulh (SCM) -- SCM-/Schaltplaneditor-Utilities

Die Definitionen und Deklarationen aus der Includedatei scm.ulh sind kompatibel zur Interpreterumgebung des Schematic Editors. In scm.ulh sind unter anderem Funktionen zum Kopieren von SCM-Elementen und zur Zuweisung von Regeln an SCM-Elemente definiert. In die Datei scm.ulh ist über Include-Anweisung die Quellcodedatei std.ulh (siehe oben) eingebunden.

4.1.3 Layout-Includedateien

lay.ulh (LAY) -- Layout-Utilities

Die Definitionen und Deklarationen aus der Includedatei lay.ulh sind kompatibel zu den Interpreterumgebungen des Layouteditors, des Autorouters und des CAM-Prozessors. In lay.ulh sind unter anderem Funktionen zur analytischen Geometrie, zur Auswertung von Netzlistendaten, zum Kopieren von Layoutelementen sowie zur Abfrage von Lagenbezeichnungen definiert. lay.ulh enthält darüber hinaus auch Funktionen für den Zugriff auf das Neuronale Regelsystem sowie die Anwendung desselben in den Layoutmodulen des Bartels AutoEngineer. In die Datei lay.ulh ist über Include-Anweisung die Quellcodedatei std.ulh (siehe oben) eingebunden.

4.1.4 IC-Design-Includedateien

icd.ulh (ICD) -- IC-Design-Utilities

Die Definitionen und Deklarationen aus der Includedatei icd.ulh sind kompatibel zur Interpreterumgebung des IC-Design-Chipeditors. In icd.ulh sind unter anderem Funktionen zur analytischen Geometrie, zum Kopieren von IC-Design-Elementen sowie zur Abfrage von Lagenbezeichnungen definiert. icd.ulh enthält darüber hinaus auch Funktionen für den Zugriff auf das Neuronale Regelsystem sowie die Anwendung desselben im IC-Design-System des Bartels AutoEngineer. In die Datei icd.ulh ist über Include-Anweisung die Quellcodedatei std.ulh (siehe oben) eingebunden.

4.2 User Language-Programme

Dieser Abschnitt enthält gegliedert nach Interpreterumgebung bzw. Anwendungsgebieten und alphabetisch sortiert eine Auflistung der mit dem Bartels AutoEngineer ausgelieferten User Language-Programme. Die hier aufgeführten User Language-Programme werden bei der Installation des Bartels AutoEngineer in einem speziell hierfür vorgesehenen Verzeichnis abgelegt.

4.2.1 Standard-Programme

Die nachfolgend aufgeführten User Language-Programme sind in allen Interpreterumgebungen des Bartels AutoEngineer (also im Schaltplaneditor, im Layouteditor, im Autorouter, im CAM-Prozessor, im CAM-View-Modul und im Chipeditor) ablauffähig.

ARC (STD) -- Kreisbogen/Kreis zeichnen

Das Programm arc.ulc ermittelt die aktuell aktive BAE-Menüfunktion und führt (sofern zulässig bzw. möglich) eine Untermenüfunktion zum schnellen Zeichnen eines Kreises oder Kreisbogens aus. Bei Aufruf ohne aktuell aktive BAE-Menüfunktion wird ein Dialog zur Auswahl des Bearbeitungsmodus aktiviert. Die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. c oder C) aufrufbar ist.

BAE_DIAL (STD) -- BAE Dialogbox-Aktion

Das Programm bae_dial.ulc wird automatisch aktiviert wenn ein Dialogboxelement mit registriertem Aktionscode selectiert wird. Die Aktivierungsdaten der Dialogbox werden von der Interaktionsqueue auf globale Variablen übertragen.

BAE_EXIT (STD) -- BAE Programmende-Aktion

Das Programm bae_exit.ulc wird automatisch vor Beednigung des aktuell aktiven BAE-Programm-Moduls aktiviert. bae_exit.ulc hebt alle aktuell aktiven Sperren für das aktuell geladene Element auf.

BAE_LOAD (STD) -- BAE Lade-/Schließen-Aktion

Das Programm bae_load.ulc wird automatisch nach dem Laden, Erzeugen oder Schließen eines Elements aktiviert. bae_load zeigt den Datei- und Elementnamen des geladenen Elements sowie den mit msmode aktuell selektierten Mausoperationsmodus in der Statuszeile an, sofern das System mit Pulldownmenüs betrieben wird. Beim Schließen des aktuell geladenen Elements wird die Datei- und Elementnamensanzeige gelöscht. Außerdem reaktiviert bae_load den ggf. zuvor mit bae_save gespeicherten, elementspezifischen Modus zur Anzeige der Werkzeugleiste.

BAE_NEW (STD) -- BAE Neues Element-Aktion

Das Programm bae_new.ulc wird automatisch nach dem Erzeugen eines Erzeugen eines Elements aktiviert. bae_new.ulc nimmt Standardparametereinstellungen für das neue Element vor.

BAE_RECT (STD) -- BAE Mausrahmenaktion

Das Programm bae_rect.ulc wird automatisch bei Betätigung der linken Maustaste aktiviert, wenn gerade keine andere Funktion aktiv ist, und im Grafikarbeitsbereich mit der Maus ein Rahmen mit einer Seitenlänge von wenigstens 10 Pixeln aufgezogen wurde. Entsprechend dem mit msmode aktuell eingestellten Mausoperationsmodus wird eine Gruppenfunktion auf die im aufgezogenen Rechteck platzierten Elemente angewendet.

BAE_SAVD (STD) -- BAE Speichern beendet Aktion

Das Programm bae_savd.ulc wird automatisch nach dem Speichern eines Elements aktiviert. bae_savd.ulc unterstützt die Ausführung eines benutzerspezifischen User Language-Programms.

BAE_SAVE (STD) -- BAE Speicheraktion

Das Programm bae_save.ulc wird automatisch vor dem Speichern eines Elements aktiviert. bae_save sichert die aktuellen Entwurfsansichten aus der Toolbar mit dem zu speichernden Element sowie den Modus zur Anzeige der Werkzeugleiste.

BAE_ST (STD) -- BAE Startup

Das Programm bae_st.ulc wird automatisch beim Aufruf von BAE-Programm-Modulen aktiviert. bae_st startet seinerseits das Programm uifsetup zur Aktivierung einer vordefinierten Menü- und Tastaturbelegung in der aktuellen Interpreterumgebung. Darüber hinaus aktiviert bae_st je nach aktuell aktiver Interpreterumgebung eines der User Language-Programme scmsetup, gedsetup, arsetup, camsetup, cvsetup und cedsetup wodurch modulspezifische Standardparameter wie Eingabe- und Hintergrundraster, Winkel- und Rasterfreigabe, Koordinatenanzeigemodus, Vorzugslage, Mincon-Funktion, usw. gesetzt werden. Alle diese Programme können selbstverständlich leicht an anwender- bzw. projektspezifische Bedürfnisse angepasst werden. bae_st startet auch ein projektspezifisches User Language-Programm wenn eine Projektdatei aktiviert ist, und wenn hierzu eine Datei mit der Endung .aut verfügbar ist. Der Name des projektspezifischen User Language-Programms wird aus der ersten Zeile der .aut-Datei entnommen.

BAE_TOOL (STD) -- BAE Toolbaraktion

Das Programm bae_tool.ulc wird automatisch bei Selektion eines Toolbarobjektes aktiviert. bae_tool löst in Abhängigkeit vom Eingabestring eine weitere Aktion aus. Hierbei werden Integerangaben als Anforderung zum Aufruf der dem Zahlenwert zugeordneten BAE-Menüfunktion interpretiert, während andere Eingaben den Aufruf eines entsprechend benannten User Language-Programms auslösen. Ein durch ein Leerzeichen getrennter String wird automatisch als Parameter an die nachfolgend aufzurufende Funktion übergeben.

BAE_ZOOM (STD) -- BAE Zoomaktion

Das Programm bae_zoom.ulc wird automatisch bei einer Änderung des Zoombereichs aktiviert. bae_zoom aktualisiert ggf. die Entwurfsansicht in der Toolbar.

BAEMAN (STD) -- BAE Windows Online-Handbuch (Windows)

Das Programm baeman.ulc aktiviert den Windows-Webbrowser zur Anzeige des Bartels AutoEngineer-Benutzerhandbuchs.

BITMAPIN (STD) -- Import Bitmap Data

Das Programm bitmapin.ulc importiert Bitmapdaten verschiedener Formate. Bei Übernahme in den Schaltplan werden die Bitmapdaten in Grafikfächen umgewandelt. Bei Übernahme in das Layoutsystem werden die Bitmapdaten in Dokumentarflächen einer angebbaren Dokumentarlage umgewandelt. Die importierten Bitmapdaten werden automatisch zur Gruppe selektiert um eine einfache Weiterbearbeitung (verschieben, skalieren, usw.) zu ermöglichen.

CLOGDEFS (STD) -- Logische Bibliotheksdefinitionen pruefen

Das Programm clogdefs.ulc ist ein Utilityprogramm für das Bibliotheksmanagement. Mit clogdefs.ulc lassen sich die SCM-Symbolnamen selektierbarer Bibliotheksdateien des aktuellen Verzeichnisses auf das Vorhandensein zugehöriger Logischer Bibliothekseinträge in einer frei wählbaren Layoutbibliothek überprüfen. Das Resultat der Bibliotheksprüfung wird in einem Popupmenü mit Ausgabeoption angezeigt.

CMDCALL (STD) -- Kommandosequenz ausfuehren

Das Programm cmdcall.ulc ermittelt die Eingabedaten einer Kommandosequenz und führt diese Kommandosequenz aus. BAE-Menükommandosequenzen sind im Funktionshandbuch beschrieben (siehe brgar.htm, brgcam.htm, brgcv.htm, brgged.htm und brgscm.htm). Dies entspricht grundsätzlich dem Verhalten der Funktion Anwenderfunktion mit dem Unterschied, dass nicht ein separates Dialogfenster sondern das BAE-Fenster selbst den Eingabefokus erhält. Damit können BAE-Operationen ferngesteuert mit Tools wie z.B. StrokeIT (Programmsteuerung über Mausgestik) ausgelöst werden. Das Programm cmdcall.ulc ist standardmässig der Tastenkombination Umschalt-Strg-R zugewiesen. D.h., ein ferngesteuerter Funktionsaufruf kann mit Umschalt-Strg-R gefolgt von der Kommandosequenz und Drücken Eingabetaste ausgelöst werden.

COPYELEM (STD) -- DDB-Dateielemente kopieren

Das Programm copyelem.ulc erlaubt analog zum Utilityprogramm copyddb das Kopieren von Elementen von einer DDB-Datei in eine andere DDB-Datei. Dabei können in einer Selektionsbox aus der Quelldatei beliebige viele Elemente der zuvor selektierten Elementklasse zum Kopieren markiert werden. Auch die Angabe von Elementnamensmustern wie z.B. 74ls* für SCM-Symbole oder dil* für Layoutgehäusebauformen ist möglich. Nach Auswahl der zu kopierenden Elemente ist die Zieldatei anzugeben sowie ggf. der Kopiermodus (Alles kopieren zum Überschreiben von existierenden Elementen in der Zieldatei, oder Keine Ersetzungen zur Beibehaltung existierender Elemente in der Zieldatei) zu selektieren. Sofern SCM-Symbole zum Kopieren ausgewählt wurden, können wahlweise auch die zugehörigen logischen Bauteildefinitionen mitkopiert werden.

DBCOPY (STD) -- SQL-Datenbanken kopieren

Mit dem Programm dbcopy.ulc können SQL-Tabellenstrukturen und Datenbankeinträge selektierbarer SQL-Datenbankdateien kopiert werden.

DBREPORT (STD) -- SQL-Datenbankreport

Das Programm dbreport.ulc dient der Anzeige der SQL-Tabellenstrukturen und Datenbankeinträge selektierbarer SQL-Datenbankdateien.

DELCOLOR (STD) -- Selektierbare Farbpalette loeschen

Mit dem Programm delcolor.ulc können selektiv Farbtabellen gelöscht werden.

DELDVINF (STD) -- Entwurfsansicht-Information löschen

Das Programm deldvinf.ulc löscht alle Informationen über Entwurfsansichten aus der DDB-Datei des aktuell geladenen Elements.

DESKCALC (STD) -- Taschenrechner

Das Programm deskcalc.ulc aktiviert in einem Popupmenü einen Taschenrechner mit Grundrechenarten und trigonometrischen Funktionen.

DIR (STD) -- Verzeichnisinhalt auflisten

Das Programm dir.ulc listet den Inhalt des aktuellen Verzeichnisses auf dem Bildschirm auf.

DISPUTIL (STD) -- Display Utilities

Das Programm disputil.ulc bietet eine einheitliche Aufrufschnittstelle für häufig benötigte, modulspezifische Bilddarstellungsfunktionen.

DISTANCE (STD) -- Distanzabfrage

Mit dem Programm distance.ulc können Distanzabfragen durchgeführt werden. Es werden dabei die absoluten, horizontalen und vertikalen Abstände sowie der Winkel zwischen zwei mausselektierbaren Koordinaten angezeigt. Die Längeneinheiten für die Abstandsanzeige werden zunächst aus dem aktuell eingestellten Koordinatenanzeigemodus ermittelt und können anschließend im Anzeigemenü geändert werden.

DONE (STD) -- Eingabeinteraktion beenden

Das Programm done.ulc dient dazu, die Eingabesequenz von Funktionen zur Erstellung bzw. Manipulation von Polygonen, Verbindungen oder Leiterbahnen zu beenden. Die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. Enter) aufrufbar ist.

FAVORITE (STD) -- Favoritenmenüverwaltung

Das Programm favorite.ulc dient der Konfiguration und Aktivierung eines benutzerdefinierten Favoritenmenüs. Dieses Programm ist zum Aufruf über eine Toolbarschaltfläche vorgesehen.

FILEUTIL (STD) -- Dateibearbeitungsfunktionen

Das Programm fileutil.ulc ermöglicht die Aktivierung einer Reihe von Dateiverwaltungsfunktionen wie z.B. das Auflisten von Verzeichnisinhalten, das Umkopieren, Löschen und Auflisten von Dateien, Suchen und Anzeigen von DDB-Elementen, die Anzeige von SQL-Datenbankinhalten, usw.

FILEVIEW (STD) -- Dateiinhalt auflisten

Das Programm fileview.ulc listet den Inhalt einer frei wählbaren ASCII-Datei auf dem Bildschirm auf.

FINDELEM (STD) -- DDB-Elemente suchen und anzeigen

Mit dem Programm findelem.ulc kann die Festplatte (d.h. angebbare Verzeichnisse mit Unterverzeichnissen) nach DDB-Elementen selektierbarer Datenbankklassen durchsucht werden. Die Namen der zu suchenden Elemente können mit Wildcards angegeben werden. Die gefundenen Elemente werden wahlweise nach Elementnamen oder nach Dateinamen sortiert. Sofern die gewählte Datenbankklasse mit der aktuellen Interpreterumgebung kompatibel ist, wird ein Browser zum Anzeigen bzw. Laden der gefundenen Elemente aktiviert.

GRTOGGLE (STD) -- Eingaberaster freigeben/einhalten

Das Programm grtoggle.ulc schaltet den Modus zur Einhaltung bzw. Freigabe des Eingaberasters um. Beim Umschalten auf den Modus zum Einhalten des Rasters wird die Einstellung für die Winkelfreigabe automatisch wiederhergestellt. Das Programm ist für den impliziten Aufruf über Tastatur (z.B. durch Zuweisung auf Hotkey g oder G) gedacht.

HELP (STD) -- Online-Hilfe

Das Programm help.ulc ermöglicht die Anzeige von Onlinedokumentation.

HISTORY (STD) -- Aufruf Elementbearbeitungshistorie

Das Programm history.ulc ermöglicht den Zugriff auf eine Dateielementhistorie mit einem Auswahlmenü für Ladeoperationen. Dieses Programm ist zum Aufruf über eine Toolbarschaltfläche vorgesehen.

HLPKEYS (STD) -- Online-Hilfe - Tastaturbelegung anzeigen

Das Programm hlpkeys.ulc zeigt die aktuell definierte Tastaturbelegung an. Die Anzeige erfolgt in einem Popupmenü mit Ausgabeoption.

HLPPROD (STD) -- Online-Hilfe - BAE-Produktinformation

Das Programm hlpprod.ulc zeigt in einem Popupmenü BAE-Produktinformationen wie z.B. die Softwarekonfiguration, die aktivierte Benutzeroberfläche, das aktive Programm-Modul, die Versionsnummer, usw. an.

INFO (STD) -- Info

Das Programm info.ulc bietet eine einheitliche Aufrufschnittstelle für häufig benötigte, interpreterspezifische Reportfunktionen. info ermittelt die aktuelle Interpreterumgebung und aktiviert in Abhängigkeit hiervon ein interpreterspezifisches Reportprogramm (scmpcr im Schaltplaneditor, laypcr im Layoutsystem, hlpprod, wenn kein Element geladen ist, usw.).

INIEDIT (STD) -- bae.ini-Editor

Mit dem Programm iniedit.ulc können allgemeine BAE-Systemparameter in der Datei bae.ini aus dem BAE-Programmverzeichnis interaktiv editiert werden. Eine Sicherungskopie des alten bae.ini-Inhalts wird unter bae.bak abgelegt.

KEYPROG (STD) -- User Language-Programmaufruf und Tastaturprogrammierung

Das Programm keyprog.ulc stellt Funktionen zum menügesteuerten User Language-Programmaufruf, zur Menübelegung und Tastaturprogrammierung sowie zur Erfassung und Pflege einer relationalen Datenbank mit Hilfstexten über User Language-Programme bereit.

LARGER (STD) -- Pickelement vergrößern/verbreitern

Das Programm larger.ulc ermittelt die aktuell aktive BAE-Menüfunktion und führt (sofern zulässig bzw. möglich) eine Untermenüfunktion zur Vergrößerung bzw. Verbreiterung des aktuell bearbeiteten Objekts durch; die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. b) aufrufbar ist.

LFTOCRLF (STD) -- Konvertierung LF nach CRLF

Das Programm lftocrlf.ulc wandelt alle Zeilenvorschub-Zeichen einer frei wählbaren ASCII-Datei in die Steuerzeichensequenz Wagenrücklauf und Zeilenvorschub um.

LIBCONTS (STD) -- Bibliotheksinhalt auflisten

Das Programm libconts.ulc ist ein Utilityprogramm für das Bibliotheksmanagement. Mit libconts.ulc kann eine Inhaltsübersicht für alle im aktuellen Verzeichnis enthaltenen DDB- und DEF-Dateien erstellt werden. Die so erzeugten Inhaltsverzeichnisse werden in Popupmenüs mit Ausgabeoptionen angezeigt.

LIBCRREF (STD) -- Bibliothekselement-Querverweisliste

Das Programm libcrref.ulc ist ein Utilityprogramm für das Bibliotheksmanagement. Mit libcrref.ulc kann eine Cross-Referenz für die Bibliothekselemente der DDB-Dateien des aktuellen Verzeichnisses erstellt werden. Die durch libcrref.ulc erzeugte Ausgabe enthält ein Listing aller selektierten Bibliothekselemente mit Angaben darüber, welche Symbole in welchen Dateien (ggf. mehrfach) definiert sind. Das Listing wird in einem Popupmenü mit Ausgabeoption angezeigt.

LISTDDB (STD) -- DDB-Dateielemente auflisten

Das Programm listddb.ulc listet die Datenbankelemente einer selektierbaren DDB-Datei in einem Popupmenü mit Ausgabeoption auf.

LOADELEM (STD) -- Laden Element mit Pruefung

Das Programm loadelem.ulc lädt ein menüselektierbares BAE-(Projekt-)Element. Bei Bedarf kann optional eine Konsistenzprüfung hinsichtlich fehlender bzw. falscher Bibliotheksdefinitionen oder noch nicht bzw. mit falschem Gehäuse platzierter Bauteile durchgeführt werden.

LOADFONT (STD) -- Laden Zeichensatz

Das Programm loadfont.ulc lädt einen menüselektierbaren Zeichensatz.

LOADNEXT (STD) -- Laden naechstes Element mit Pruefung

Das Programm loadnext.ulc ermittelt Name und Klasse des aktuell geladenen Elements und lädt automatisch das Element derselben Klasse, welches in der Namensliste der zugehörigen DDB-Datei direkt nach dem aktuell geladenen eingetragen ist (vorwärtsblättern). Ist das zu ladende Element auf diese Weise nicht zu ermitteln, dann wird ein menüselektierbares Element geladen. Bei Bedarf kann optional eine Konsistenzprüfung hinsichtlich fehlender bzw. falscher Bibliotheksdefinitionen oder noch nicht bzw. mit falschem Gehäuse platzierter Bauteile durchgeführt werden.

LOADPREV (STD) -- Laden vorheriges Element mit Pruefung

Das Programm loadprev.ulc ermittelt Name und Klasse des aktuell geladenen Elements und lädt automatisch das Element derselben Klasse, welches in der Namensliste der zugehörigen DDB-Datei direkt vor dem aktuell geladenen eingetragen ist (rückwärtsblättern). Ist das zu ladende Element auf diese Weise nicht zu ermitteln, dann wird ein menüselektierbares Element geladen. Bei Bedarf kann optional eine Konsistenzprüfung hinsichtlich fehlender bzw. falscher Bibliotheksdefinitionen oder noch nicht bzw. mit falschem Gehäuse platzierter Bauteile durchgeführt werden.

LROTATE (STD) -- Pickelement Linksdrehung, Winkelrichtung wechseln

Das Programm lrotate.ulc ermittelt die aktuell aktive BAE-Menüfunktion der aktuellen Interpreterumgebung und führt (sofern zulässig bzw. möglich) eine Untermenüfunktion zur Drehung des aktuell bearbeiteten Objekts um 90 Grad nach links durch; die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. l bzw. L) aufrufbar ist.

Im Layouteditor kann mit der Funktion L/R Drehwinkel des User Language-Programms gedpart der von lrotate zu verwendende Drehwinkel für Bauteile, Pins, Polygone, Texte und Gruppen auf einen (beliebigen) von 90 Grad abweichenden Wert eingestellt werden.

MACRO (STD) -- Makrokommandoverwaltung

Das Programm macro.ulc bietet Funktionen zum Erstellen und Abrufen von Makrokommandosequenzen.

MIRROFF (STD) -- Pickelement Spiegelung aus

Das Programm mirroff.ulc ermittelt die aktuell aktive BAE-Menüfunktion der aktuellen Interpreterumgebung und führt (sofern zulässig bzw. möglich) eine Untermenüfunktion zum Zurücksetzen des Spiegelungsmodus des aktuell bearbeiteten Objekts durch; die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. n bzw. N) aufrufbar ist.

MIRRON (STD) -- Pickelement Spiegelung ein, Editierrichtung wechseln

Das Programm mirron.ulc ermittelt die aktuell aktive BAE-Menüfunktion der aktuellen Interpreterumgebung und führt (sofern zulässig bzw. möglich) eine Untermenüfunktion zur Spiegelung des aktuell bearbeiteten Objekts durch; die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. m bzw. M) aufrufbar ist.

MMB (STD) -- Interaktion Mittlere Maustaste

Das Programm mmb.ulc simuliert die Betätigung der mittleren Maustaste zur Aktivierung des Online-Bilddarstellungsmenüs. mmb ist für die Zuweisung auf eine Standardtaste (z.B. Leertaste) zur komfortablen Aktivierung des Menüs Bilddarstellung über die Tastatur vorgesehen.

MSMODE (STD) -- Maus Kontextmodus selektieren

Mit dem Programm msmode.ulc kann ein Mausoperationsmodus (Keine Operation, Kontextfunktionen, Löschen, Bewegen, Selektieren) selektiert werden, welcher objektspezifische Funktionen festlegt, die automatisch auf mit der linken Maustaste angeklickte Elemente angewendet werden.

OSSHELL (STD) -- Betriebssystem-Shell aktivieren

Das Programm osshell.ulc startet einen Kommandointerpeter zur Ausführung von Betriebssystemkommandos. Hierzu wird die User Language-Funktion system zum Aktivieren der Kommandos benutzt. Vor Benutzung dieses Programms sollten Sie unbedingt die Einschränkungen hinsichtlich der Anwendung der Funktion system beachten!

RENAMEEL (STD) -- DDB-Dateielemente umbenennen

Das Programm renameel.ulc bietet eine Funktion zur DDB-Dateielement-Umbenennung. Verfügbare Elementklassen werden hierbei in Abhängigkeit von der aktuellen Interpreterumgebung angeboten.

RROTATE (STD) -- Pickelement Rechtsdrehung, Rechteck Zeichnen

Das Programm rrotate.ulc ermittelt die aktuell aktive BAE-Menüfunktion der aktuellen Interpreterumgebung und führt (sofern zulässig bzw. möglich) eine Untermenüfunktion zur Drehung des aktuell bearbeiteten Objekts um 90 Grad nach rechts durch; die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. r bzw. R) aufrufbar ist.

Im Layouteditor kann mit der Funktion L/R Drehwinkel des User Language-Programms gedpart der von rrotate zu verwendende Drehwinkel für Bauteile, Pins, Polygone, Texte und Gruppen auf einen (beliebigen) von 90 Grad abweichenden Wert eingestellt werden.

SAVEELAS (STD) -- Ablegen auf Namen

Das Programm saveelas.ulc speichert das aktuell geladene Element unter einem frei wählbaren Datei- und Elementnamen. Existiert das selektierte Zielelement bereits, dann erfolgt eine Abfrage, ob dieses Element überschrieben werden soll.

SIZE (STD) -- Größenänderung aktuelles Element

Das Programm size.ulc ermittelt die aktuell aktive BAE-Menüfunktion der aktuellen Interpreterumgebung und führt (sofern zulässig bzw. möglich) eine Untermenüfunktion zur Änderung der Göße des aktuell bearbeiteten Objekts durch; die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. s bzw. S) aufrufbar ist. Die neue Objektgröße wird über ein Optionsmenü mit einer Liste vordefinierter Werte und einer Funktion zur Eingabe eines spezifischen Wertes eingestellt.

SMALLER (STD) -- Pickelement verkleinern/verschmälern

Das Programm smaller.ulc ermittelt die aktuell aktive BAE-Menüfunktion und führt (sofern zulässig bzw. möglich) eine Untermenüfunktion zur Verkleinerung bzw. Verschmälerung des aktuell bearbeiteten Objekts durch; die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. B) aufrufbar ist.

STEPDOWN (STD) -- Um eine Lage runterwechseln

Das Programm stepdown.ulc ermittelt die aktuell aktive BAE-Menüfunktion und führt im Layouteditor (sofern zulässig bzw. möglich) eine Untermenüfunktion zum Wechsel auf die nächstniedrigere Lage aus. Die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. ), Ctrl/Mausrad abwärts) aufrufbar ist.

STEPUP (STD) -- Um eine Lage hochwechseln

Das Programm stepup.ulc ermittelt die aktuell aktive BAE-Menüfunktion und führt im Layouteditor (sofern zulässig bzw. möglich) eine Untermenüfunktion zum Wechsel auf die nächsthöhere Lage aus. Die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. (, Ctrl/Mausrad aufwärts) aufrufbar ist.

TBATTACH (STD) -- Toolbar ausrichten

Mit dem Programm tbattach.ulc kann die mit toolbar aktivierte Werkzeugleiste an einer der vier Begrenzungen (links, rechts, oben oder unten) des Arbeitsbereiches angeordnet werden. Wahlweise besteht auch die Möglichkeit, die Werkzeugliste auszublenden.

TOOLBAR (STD) -- Toolbar

Das Programm toolbar.ulc aktiviert eine Werkzeugleiste (Toolbar) mit Zusatzfunktionen zur grafikgestützten Verwaltung von Entwurfsansichten und Schaltflächen für den komfortablen Aufruf häufig benötigter Dateizugriffs-, Zoom- und Reportfunktionen und zur Einstellung des Mausoperationsmodus.

UIFDUMP (STD) -- Menu- und Tastaturbelegung ausgeben

Das Programm uifdump.ulc erzeugt ein Listing über die komplette Menü- und Tastaturbelegung des aktuell aktiven BAE-Programm-Moduls. Das Listing wird in einem Popupmenü mit Ausgabeoption angezeigt.

UIFRESET (STD) -- Menue- und Tastaturbelegung zuruecksetzen

Das Programm uifreset.ulc setzt die komplette Menü- und Tastaturbelegung des aktuell aktiven BAE-Programm-Moduls zurück.

UIFSETUP (STD) -- Menue- und Tastaturbelegung aktivieren

Das Programm uifsetup.ulc dient der automatisierten Aktivierung einer vordefinierten Menü- und Tastaturbelegung im aktuell aktiven BAE-Programm-Modul. uifsetup kann durch Aufruf über das User Language-Programm bae_st automatisiert über die Startupsequenz der einzelnen Interpreterumgebungen aktiviert werden.

ZOOMIN (STD) -- Zoom größer

Das Programm zoomin.ulc führt das Zoom größer-Kommando im Bartels AutoEngineer aus.

ZOOMOUT (STD) -- Zoom kleiner

Das Programm zoomout.ulc führt das Zoom kleiner-Kommando im Bartels AutoEngineer aus.

4.2.2 SCM-Programme

Die nachfolgend aufgeführten User Language-Programme sind in der Interpreterumgebung des Schaltplaneditor ablauffähig.

ATTRSET (SCM) -- SCM-Symbol Attributwertzuweisung

Das Programm attrset.ulc aktiviert einen Dialog mit erweiterten Funktionen zur Zuweisung von Attributwerten an mausselektierbare SCM-Symbole.

CHKSMAC (SCM) -- Nicht definierte SCM-Makroreferenzen auflisten

Das Programm chksmac.ulc listet die Namen aller undefinierten Makroreferenzen des aktuell geladenen SCM-Elements in einem Popupmenü mit Ausgabeoption auf.

DEF2CSV (SCM) -- Symboldatenbank aus .def-Dateien erzeugen

Das Programm def2csv.ulc durchsucht ein auswählbares Verzeichnis nach .def-Dateien mit logischen Bauteildefinitionen und erzeugt daraus .csv- und .map-Dateien zur Erzeugung von Symbolauswahldatenbanken mit den User Language-Programmen symattdb.ulc und symmapdb.ulc. Die Bibliotheksnamen für die Symbole werden aus dem Namen der .def-Datei abgeleitet. D.h., def2csv.ulc sollte nur auf .def-Dateien angewendet werden für eine Symboldatenbank mit einem entsprechenden Dateinamen existiert.

FINDSPRT (SCM) -- SCM-Bauteilsuche

Das Programm findsprt.ulc dient der Suche von Bauteilen im aktuell geladenen Stromlaufplan. Das Auswahlmenü zur Selektion des zu suchenden Bauteils zeigt sämtliche Bauteile des aktuellen Stromlaufplans (mit allen zugehörigen Blättern), wobei für jedes Bauteil der Planname, der SCM-Bauteilname und der vom Packager zugewiesene physikalische Bauteilname angegeben ist. Soll ein Bauteil auf einem anderem als dem aktuell geladenen Stromlaufblatt gesucht werden, dann erfolgt im Bedarfsfall eine Abfrage, ob das aktuell geladene Element gesichert bzw. die Suche tatsächlich durchgeführt werden soll. Zusatzoptionen ermöglichen eine Suche direkt nach SCM- bzw. Layoutbauteilname sowie die Lokalisierung von Bauteilen mit selektierbaren Attributwerten. Das Programm führt mit der Bilddarstellungsfunktion Fenster Mitte automatisch einen Zoom auf das gefundene Bauteil aus.

LOGLEDIT (SCM) -- Loglib-Editor-Funktionen

Mit dem Programm logledit.ulc können logische Bibliotheksdefinitionen im Schaltplaneditor geladen, editiert und kompiliert werden. Auf SCM-Symbolebene wird die logische Bibliotheksdefinition des aktuell bearbeiteten Symbols geladen. Es wird eine Templatedefinition mit allen Symbolpins automatisch erzeugt, sofern noch keine zugehörige logische Bibliotheksdefinition existiert. Auf Schaltplanebene kann die zu bearbeitende Loglibdefinition durch Selektion eines auf dem Stromlaufblatt platzierten Symbols gewählt werden. Bei allen anderen Elementklassen erfolgt eine Symbolnamensabfrage. Die zugehörige Loglibdefinition kann dann entweder aus der aktuell bearbeitenden Designdatei, der Defaultbibliothek oder einer beliebigen anderen DDB-Datei geladen werden. Sobald die Loglibdefinition geladen ist, kann sie editiert und abschließend mit dem Button OK kompiliert werden. Das Format der Loglibdefinitionen ist ausführlich in der Beschreibung des Utilityprogramms loglib dokumentiert.

NETCONV (SCM) -- Logische Netzliste einlesen

Das Programm netconv.ulc dient dazu, logische (d.h. ungepackte) Netzlisten aus unterschiedlichen ASCII-Formaten (BAE, ALGOREX, Applicon, CADNETIX, CALAY, EEDESIGNER, Marconi ED, Mentor, MULTIWIRE, OrCAD, PCAD, RINF, SCICARDS, TANGO, VECTRON, VUTRAX, WIRELIST) in den Bartels AutoEngineer zu übertragen. Nach Auswahl der Netzlistendatei <project>.net werden die Netzlistendaten eingelesen und die darin enthaltene logische Netzliste wird in der DDB-Datei <project>.ddb unter dem in der Eingabedatei spezifizierten Namen (Default netlist) abgelegt. Diese logische Netzliste lässt sich dann mit dem Packager in eine physikalische (d.h. gepackte) Netzliste umwandeln. Anschließend kann das zugehörige Layout erstellt werden, wobei dann auch Pin- und Gattertausch entsprechend den durch den Packager übertragenen swap-Kommandos aus der logischen Bibliothek durchgeführt werden kann. Für Konsistenzprüfungen werden die Pinlisten der in der Netzliste referenzierten SCM-Symbole benötigt; netconv sucht zunächst in der Zielprojektdatei (<project>.ddb) und anschließend in einer im Quellcode vordefinierten Liste von SCM-Bibliotheksdateien nach den erforderlichen Symboldefinitionen. Netzattribute zur Autorouter-Steuerung (ROUTWIDTH, POWWIDTH, MINDIST, PRIORITY) werden durch den Anschluss synthetisch generierter Netzattribut-Bauteile übertragen; die hierfür benötigten Namensreferenzen (Netzattribut-Symbolname, Pinname, Netzattributname) sind im Quellcode vordefiniert. Der Fortgang der Bearbeitung sowie eventuell auftretende Fehler und Warnungen werden am Bildschirm und in einer Protokolldatei mit Namen bae.log aufgelistet. Nach erfolgreicher Übernahme der Netzliste erfolgt der Hinweis, dass ein Packager-Lauf durchzuführen ist.

PERRLIST (SCM) -- Anzeige Packager-Fehlerliste

Das Programm perrlist.ulc aktiviert ein permanent sichtbares Dialogfenster zur Anzeige von Packager-Fehlermeldungen mit Optionen zum Zoom auf selektierbare Fehlersymbole.

PLANSORT (SCM) -- SCM-Plan sortieren/nummerieren

Das Programm plansort.ulc führt für selektierbare DDB-Dateien des aktuellen Verzeichnisse eine automatische Benennung bzw. Nummerierung der SCM-Plannamen durch.

SADDNAME (SCM) -- SCM-Symbolname definieren

Das Programm saddname.ulc ermöglicht die halbautomatische Platzierung eines Textes dessen Inhalt dem Makronamen des aktuell geladenen SCM-Symbols entspricht.

SAUTONAM (SCM) -- Automatische Schaltplansymbolbenennung/-Nummerierung

Das Programm sautonam.ulc ermöglicht die Aktivierung verschiedener Funktionen zur automatischen Umbenennung bzw. Nummerierung von Bauteilen auf dem aktuell bearbeiteten Schaltplan. Die Nummerierung der Bauteile erfolgt jeweils von links oben nach rechts unten auf dem Stromlaufblatt. Die Bauteilnummerierung kann wahlweise auf das aktuell geladene Stromlaufblatt (Option Aktuelles Blatt) oder auf alle Blätter des aktuell geladenen Stromlaufplans angewendet werden (Option Alle Blätter).

SBROWSE (SCM) -- Schaltplansymbolbrowser

Das Programm sbrowse.ulc ermöglicht die Auswahl zu ladender bzw. zu platzierender SCM-Bibliothekselemente, wobei in einem Popupmenü eine grafische Voranzeige des aktuell selektierten Bibliothekselements erfolgt.

SCM_GRPL (SCM) -- SCM Gruppenladeaktion

Das Programm scm_grpl.ulc wird automatisch nach dem Laden von Gruppen aktiviert. scm_grpl aktualisiert Symbolvariantenattribute.

SCM_MS (SCM) -- SCM Mausaktion

Das Programm scm_ms.ulc wird automatisch beim Drücken der linken Maustaste gestartet wenn gerade keine andere Schaltplaneditor-Funktion aktiv ist. scm_ms aktiviert ein kontextsensitives Funktionsmenü für das Objekt an der aktuellen Mausposition. Ist kein Element geladen, dann werden die Funktionen Element Laden, Neues Element und Mausmodus angeboten.

SCM_MSG (SCM/HighEnd) -- SCM Messagesystem-Aktion

Das Programm scm_msg.ulc empfängt und bearbeitet Messages aus anderen BAE HighEnd Modulen. Die auszulösenden Aktionen (Setzen von Variablen, Aufruf von User Language-Programmen) sowie die zu bearbeitenden Objekte werden jeweils durch die eingehende Meldung bestimmt.

SCM_PLC (SCM) -- SCM Symbolplatzierungsaktion

Das Programm scm_plc.ulc wird automatisch nach der Platzierung eines Symbols aktiviert. scm_plc aktualisiert den Platzierungssymbolpool ("Warenkorb").

SCMBOUND (SCM) -- SCM-Arbeitsbereich/Elementgrenzen setzen

Das Programm scmbound.ulc führt wahlweise eine Vergrößerung oder Verkleinerung der Elementgrenzen des aktuell geladenen Elements durch.

SCMCON (SCM) -- SCM-Verbindungsfunktionen

Das Programm scmcon.ulc ermöglicht die Aktivierung spezieller Verbindungsfunktionen wie Änderung des Busdarstellungsmodus, Busabfrage oder Netzhighlight.

SCMCRREF (SCM) -- SCM-Plan Bauteil-/Labelliste erstellen

Das Programm scmcrref.ulc erzeugt eine Bauteil- und Label-Cross-Referenz für den Stromlauf einer selektierbaren Projektdatei und zeigt diese in einem Popupmenü mit Ausgabeoption an. Datei aus.

SCMDISP (SCM) -- SCM-Bilddarstellungsfunktionen

Das Programm scmdisp.ulc ermöglicht die Aktivierung einer Reihe zusätzlicher Bilddarstellungsfunktionen im Schaltplaneditor.

SCMDRAW (SCM) -- SCM-2D-Zeichnungsfunktionen

Das Programm scmdraw.ulc ermöglicht die Aktivierung verschiedener 2D-Zeichnungsfunktionen zur Generierung von Kreisen, Rechtecken und Pfeilen, zur Distanzbemaßung sowie zur Linealerzeugung.

SCMDUMP (SCM) -- SCM-ASCII-Dump

Das Programm scmdump.ulc gibt einen ASCII-Dump des aktuell geladenen SCM-Elements auf Datei aus.

SCMDXFDI (SCM) -- SCM AutoCAD/DXF-Übernahme

Das Programm scmdxfdi.ulc ermöglicht das Einlesen von Zeichnungsdaten im Format AUTOCAD-DXF auf das aktuell geladene Schaltplanelement, wobei Eingabe-Längeneinheiten, Einleseoffset und zu übernehmende Lagen frei wählbar sind.

SCMDXFDO (SCM) -- SCM AutoCAD-DXF-Ausgabe

Das Programm scmdxfdo.ulc erzeugt eine AUTOCAD-DXF-Ausgabe für das aktuell geladene SCM-Element.

SCMEDFDI (SCM) -- SCM EDIF-Daten importieren

Das Programm scmedfdi.ulc dient dazu, Schaltplandaten, d.h. Netzlisten, Schaltzeichen und Stromlaufpläne aus dem Format EDIF in den Schaltplaneditor des Bartels AutoEngineer zu übertragen. Die für den anschließenden Packager-Lauf erforderlichen Definitionen in der logische Bauteilbibliothek werden nach Bedarf automatisch erzeugt.

SCMEPS (SCM) -- SCM EPS/PDF Ausgabe

Das Programm scmeps.ulc erzeugt für das aktuell geladene SCM-Element wahlweise eine Ausgabe im Adobe Portable Document Format (PDF) oder im Encapsulated PostScript (EPS) Format, wobei verschiedene Skalierungsfaktoren für die Ausgabe zur Auswahl stehen. Über eine Option kann ein interaktiv festlegbarer Bereich für die Ausgabe selektiert werden. Es werden die verschiedenen Grafikobjekte (Standard- bzw. Kommentartext, Dokumentarflächen, Dokumentarlinien, gestrichelte Linien, Kontaktbereiche, Verbindungen, Busse) der unterschiedlichen Hierarchieebenen (Stromlaufblatt, Symbol, Label, Marker) simultan geplottet, wobei zusätzlich Ausgabeoptionen für Füllmodus, Farb- bzw. Grauwert, Schraffur und gestrichelte Linien spezifiziert werden können. Die auszugebenden Objekte sowie die Ausgabeoptionen sind in einer - an firmenspezifische Konventionen anpaßbaren - speziellen Variablen im Quellcode von scmeps festgelegt. Darüberhinaus werden mit scmrule an Plotelemente zugewiesene Plotsichtbarkeitsregeln entsprechend berücksichtigt.

SCMGROUP (SCM) -- SCM-Gruppenfunktionen

Das Programm scmgroup.ulc ermöglicht die automatische Selektion bzw. De-Selektion aller Objekte eines selektierbaren Typs oder mit spezifischen Attributen, das Laden von Gruppen aus anderen Datenbankhierarchieebenen, die Änderung der Größe gruppenselektierter Texte, sowie die globale Attributwertzuweisung an gruppenselektierte Bauteile. Eine Spezialfunktion zur Selektion von Layoutbauteilmengen entsprechend der selektierten SCM-Symbole wird ebenfalls angeboten.

SCMIO (SCM) -- SCM-Ein-/Ausgabefunktionen

Das Programm scmio.ulc aktiviert im Schaltplaneditor ein Menü mit verschiedenen SCM-spezifischen Ein-/Ausgabefunktionen. Über das Kommando addioitem können in der Datei bae.ini im BAE-Programmverzeichnis in einfacher Weise zusätzliche (benutzerspezifische) Import-/Exportfunktionen in das Menü aufgenommen werden.

SCMMACL (SCM) -- Schematic Makro Laden

Das Programm scmmacl.ulc l&aeuml;dt das Bibliothekselement eines mausselektierbaren Symbols, Labels oder Markers des aktuell geladenen SCM-Elements in den Schaltplaneditor.

SCMPART (SCM) -- SCM-Symbol-/Labelfunktionen

Das Programm scmpart.ulc ermöglicht die Aktivierung einer Reihe von Symbol- und Labelfunktion wie z.B. Drehen bzw. Rotieren selektierbarer Symbole bzw. Labels, Bauteilumbenennung, Symbol- und Labelabfrage, Bauteilsuche, Stücklistenausgabe, menügesteuerte Attributwertzuweisung, usw.

SCMPCR (SCM) -- SCM-Report

Das Programm scmpcr.ulc zeigt einen Report über das aktuell geladene SCM-Element in einem Popupmenü mit Ausgabeoption an.

SCMPEDIT (SCM) -- SCM Positionspick/Elementdatenmanipulation

Das Programm scmpedit.ulc bietet Funktionen zur automatischen Positions- bzw. Pickpunktanwahl anhand der an der aktuellen Mausposition platzierten Elemente. Die Funktionsfähigkeit dieses Programms ist nur gewährleistet, wenn es implizit über Tastendruck (z.B. p oder P) aufrufbar ist.

SCMPLOT (SCM) -- SCM-Plan plotten

Das Programm scmplot.ulc plottet unter Verwendung der aktuell eingestellten Plotparameter (für Ausgabekanal, Maßstab, etc.) sämtliche SCM-Pläne einer selektierbaren DDB-Datei, wobei zwischen den Ausgabeformaten PostScript und HP-Laser (PCL) gewählt werden kann.

SCMPOLY (SCM) -- SCM-Polygonfunktionen

Das Programm scmpoly.ulc ermöglicht die Aktivierung einer Reihe von Polygonbearbeitungsfunktionen wie z.B. die Definition bzw. Änderung von Polygontypen, das Spiegeln von Polygonen, das Kopieren gruppenselektierter Polygone mit Skalierung, die Aktivierung verschiedener 2D-Zeichnungsfunktionen, usw.

SCMRULE (SCM) -- SCM-Regelzuweisungsutility

Mit dem Programm scmrule.ulc können im Schaltplaneditor Regeln an Schaltplanelemente zugewiesen werden. Um Regelsystemfehler zu vermeiden, sind die zugewiesenen Regeln mit dem Regelsystem-Compiler rulecomp zu definieren bzw. zu kompilieren.

SCMSETUP (SCM) -- Schematic Editor Setup

Das Programm scmsetup.ulc stellt eine Reihe von SCM-Parametern und Bilddarstellungsmodi auf Defaultwerte ein.

SCMTEXT (SCM) -- SCM-Textfunktionen

Das Programm scmtext.ulc ermöglicht die Aktivierung einer Reihe von Textfunktionen wie z.B. Ändern und Ersetzen von Texten, Setzen von Textgrößen, Umwandlung selektierbarer Texte in Standard- oder Kommentartext, Zuweisung von Textklassen zur Steuerung der Textsichtbarkeit, Konvertierung von Texten in Flächen oder Linien, Generierung kreisbogenförmig geschriebener Texte, usw.

SCMVAR (SCM) -- Schaltplanvariante selektieren

Das Programm scmvar.ulc aktiviert eine selektierbare Schaltplanvariante mit optionalem Transfer variantenspezifischer Daten.

SLABCHK (SCM) -- SCM Labelnamen ueberpruefen

Das Programm slabchk.ulc prüft die Labels sämtlicher Stromlaufblätter eines Projekts durch. Labels bzw. Netznamen, die nur einmal im gesamten Schaltplan definiert bzw. referenziert sind, werden als mögliche Fehler gekennzeichnet.

SLIBCOMP (SCM) -- SCM-Bibliothekselemente vergleichen

Das Programm slibcomp.ulc ist ein Utilityprogramm für das SCM-Bibliotheksmanagement. slibcomp.ulc vergleicht die Bibliotheksdefinitionen (Pinnamen, Pinplatzierung, Verwendung von Pinmakros, Zuordnung zu Einträgen in der logischen Bibliothek, etc.) selektierbarer Stromlaufsymbole und zeigt das Ergebnis des Bibliotheksvergleichs in einem Popupmenü mit Ausgabeoption an.

SLIBDOC (SCM) -- SCM-Bibliotheksdokumentation

Das Programm slibdoc.ulc erzeugt in selektierbaren SCM-Bibliotheksdateien des aktuellen Verzeichnisses Stromlaufblätter, auf die sortiert nach Namen die in der jeweiligen DDB-Datei enthaltenen SCM-Symbole automatisch platziert werden. Die so erzeugten Stromlaufblätter können optional im Batchbetrieb im Format PostScript ausgeplottet und als Bibliotheks-Dokumentation (Bauteilmappe) verwendet werden. Die Dokumentation kann wahlweise für SCM-Symbole oder SCM-Labels erstellt werden, wobei eine Selektion über Symbolnamensmuster möglich ist. Es stehen unterschiedliche Blattformate für die Ausgabe zur Verfügung.

SLIBNEWS (SCM) -- SCM-Bibliothek mit neuen Symbolen erzeugen

Das Programm slibnews.ulc ist ein Utilityprogramm für das SCM-Bibliotheksmanagement. Mit slibnews werden aus einer selektierbaren DDB-Datei die SCM-Elemente, die nicht in der aktuellen BAE-Bibliothek enthalten sind, in eine Temporärdatei kopiert. Aus der so erzeugten Bibliotheksdatei kann anschließend eine kontrollierte Übernahme bzw. Freigabe der neuen SCM-Bibliothekselemente erfolgen.

SLIBUTIL (SCM) -- SCM-Bibliotheksmanagement

Das Programm slibutil.ulc ermöglicht die Aktivierung einer Reihe von SCM-Bibliotheksmanagement-Utilities wie etwa zur Erzeugung von Bibliotheks-Cross-Referenzen, zur automatischen Generierung von Bibliotheks-Dokumentation, zum Kopieren bzw. Löschen menüselektierbarer DDB-Dateielemente, zur Durchführung von Bibliotheks-Konsistenzprüfungen, zum Exportieren von Loglib-Definitionsdateien, usw.

SMOVPINN (SCM) -- SCM-Symbol-Pinnamen verschieben

Das Programm smovpinn.ulc bewegt die Namen der oberen und unteren Pins des aktuell geladenen SCM-Symbols auf die jeweiligen Pin-Nullpunkte (und gibt dadurch bei geeigneter Pin-Makro-Definition die Bereiche für das Verlegen von Netzanschlüssen an diese Pins frei).

SNEXTSYM (SCM) -- SCM Folgesymbol platzieren

Das Programm snextsym.ulc platziert das nächste Symbol aus dem Projektsymbolpool ("Warenkorb") bzw. wiederholt die Platzierung des vorherigen Symbols, falls der Pool leer ist.

SPICESIM (SCM) -- Spice-Netzlistenausgabe

Das Programm spicesim.ulc dient der Generierung von Spice-Netzlisten. Es können wahlweise Netzlisten für ein ganzes Schaltplanblatt (Option Gesamtes Blatt) oder für die in der Gruppe selektierten Symbole (Option Gruppensymbole) ausgegeben werden. Die Ausgabe erfolgt auf eine Datei mit der Dateiendung .cir. In diese Datei sollten zusätzliche Kommandos wie etwa .LIB und .INCLUDE zur Adressierung der Spice-Bibliotheken und zur Definition von Kontrollparametern für die Spice-Simulation eingetragen werden. Die Zuweisung von Spice-Modelltypen an SCM-Symbole und die Festlegung der Ausgabereihenfolge der Symbolpins kann mit Hilfe der Funktionen Spice Modell und Spice Pinabfolge des User Language-Programms scmrule vorgenommen werden.

SPOPCOL (SCM) -- SCM-Farbauswahl

Das Programm spopcol.ulc aktiviert ein Popupmenü zur Anzeige und Definition der aktuellen Farbeinstellungen im Schaltplaneditor.

SSPINMAC (SCM) -- SCM-Symbol Pinmakros setzen

Das Programm sspinmac.ulc setzt alle Marker-Makros des aktuell geladenen SCM-Elements automatisch auf ihren Default zurück.

SSVGOUT (SCM) -- Schaltplan SVG (Scalable Vector Graphics) Ausgabe

Das Programm ssvgout.ulc generiert aus dem aktuell geladenen Schaltplanelement eine Exportdatei im Format SVG (Scalable Vector Graphics).

SSYMATTR (SCM) -- SCM-Symbol Attributdatenbankmanagement

Das Programm ssymattr.ulc enthält SQL-Routinen zur Definition und Pflege vordefinierter Bauteilattribute für Kondensator- und Widerstandsreihen in einer relationalen Datenbank. Darüber hinaus stellt ssymattr.ulc auf Schaltplanebene entsprechende Funktionen zur halbautomatischen Bauteil-Attributdefinition und zum Setzen von Defaultattributen bereit.

SSYMEDIT (SCM) -- SCM-Symbol-Editierfunktionen

Das Programm ssymedit.ulc ermöglicht bei geladenem SCM-Symbol den menügesteuerten Aufruf einer Reihe von Symbol-Editierfunktionen. Zur Auswahl stehen unter anderem Routinen zum Setzen des Symbol-Nullpunkts, zum Platzieren von Pins, zum Umplatzieren von Pingruppen, zur Änderung der Elementgrenzen, usw.

SSYMORIG (SCM) -- SCM-Symbol-Nullpunkt setzen

Das Programm ssymorig.ulc setzt den Nullpunkt des aktuell geladenen SCM-Symbols automatisch auf einen selektierbaren Pin.

SSYMPATT (SCM) -- SCM-Symbol-Namensmustereinstellungen

Das Programm ssympatt.ulc zum Setzen von Basis-Namensmustern für die automatische Benennung von Symbolen. Auf Symbolebene kann ein Namensmuster spezifiziert werden. Auf Schaltplanebene kann ein Benennungmodus (Standard oder Nummernscan) und optional eine Startnummer für die Benennung angegeben werden.

STXFIN (SCM) -- TXF Schaltplan-Datenübernahme

Das Programm stxfin.ulc importiert TXF-Schaltplandaten aus einer selektierbaren ASCII-Datei in den Schaltplaneditor

SYMATTDB (SCM) -- SQL-Attributdatenbank zur SCM-Symbolselektion aufbauen

Das Programm symattdb.ulc gestattet die Generierung einer SQL-Datenbank zur Symbolselektion. Die Datenbank wird durch Importieren von .csv-Dateiinhalten aus einem selektierbaren Verzeichnis erzeugt.

SYMEDBAT (SCM) -- SCM-Symbol Batcheditor

Das Programm symedbat.ulc ermöglicht die Definition einer Reihe von Aktionen zum Editieren von Symbolen sowie die automatische Durchführung all dieser Editieraktionen für die SCM-Symbole selektierbarer SCM-Bibliotheksdateien des aktuellen Verzeichnisses. Zur Auswahl stehen Funktionen zum Definieren, Ändern oder Löschen spezieller Texte, zur Minimierung der Elementgrenzen, zum Rücksetzen von Pin-Makros, zum Setzen des Symbol-Nullpunkts, zur Zuweisung von Defaultattributen, zur automatisierten Platzierung von Texten, usw.

SYMMAPDB (SCM) -- SQL-Symbolgatterzuordnungsdatenbank aufbauen

Das Programm symmapdb.ulc gestattet die Generierung einer SQL-Datenbank zur Symbolgatterauswahl. Die Datenbankeinträge können aus einer .map-Datei importiert werden.

SYMSEL (SCM) -- SCM-Symbolplatzierung mit Auswahl aus Attributdatenbank

Das Programm symsel.ulc gestattet die Platzierung von Symbolen mit Auswahl aus einer mit symattdb erzeugten Attribut- bzw. Symbolselektionsdatenbank.

TBDVSCM (SCM) -- SCM Entwurfsansichten in Toolbar verwalten

Das Programm tbdvscm.ulc bearbeitet Anforderungen zur Aktualisierung von SCM-Entwursfansichten und verwaltet ein Utility zur automatischen Zuweisung von Attributen an Bauteile und zur Platzierung von Symbolkopien.

4.2.3 Layout-Programme

Die nachfolgend aufgeführten User Language-Programme sind in den Interpreterumgebungen des Layouteditor, des Autorouters und des CAM-Prozessors ablauffähig.

AIRLDENS (LAY) -- Airline-Dichteverteilungsdiagramm

Das Programm airldens.ulc generiert eine farblich abgestufte grafische Anzeige der Dichteverteilung der Airlines des aktuell geladenen Layouts. Die Skalierung des Anzeigebereichs ergibt sich hierbei aus der Auflösung des aktuell eingesetzten Grafiksystems.

CHECKLNL (LAY) -- Layout gegen Netzliste pruefen

Das Programm checklnl.ulc prüft das aktuelle Layout gegen die Netzlistendaten und zeigt einen Report über noch nicht platzierte Bauteile, falsche Gehäusebauformen und fehlende Pindefinitionen in einem Popupmenü mit Ausgabeoption an.

CHKLMAC (LAY) -- Nicht definierte Layout-Makroreferenzen auflisten

Das Programm chklmac.ulc listet die Namen aller undefinierten Makroreferenzen des aktuell geladenen Layoutelements in einem Popupmenü mit Ausgabeoption auf.

CONBAE (LAY) -- Netzlistenausgabe

Das Programm conbae.ulc gibt die Netzliste des aktuell geladenen Layouts im BAE-ASCII-Netzlistenformat auf Datei aus, wobei wahlweise eine Sortierung der Bauteil- und Netznamen durchgeführt wird. Die Ausgabe von Bauteilplatzierungsdaten ebenso wie die Ausgabe von Netzen mit nur einem Pin und die Ausgabe automatisch generierter Testpunkte kann optional veranlasst werden.

DRILLOUT (LAY) -- Bohrdatenausgabe

Das Programm drillout.ulc gibt die Bohrdaten des aktuell geladenen Layouts im Sieb&Meier- oder im Excellon-Format aus. Daneben wird auch eine Option zur Anzeige einer Bohrdatenstatistik angeboten. Die Bohrklasse für die Ausgabe ist über Menü selektierbar. Die Dateinamen der Ausgabedateien werden automatisch generiert. Die Werkzeugtabelle wird selbsttätig ermittelt, sofern für die Bohrdatenausgabe nicht die im Programm vordefinierte Bohrertabelle verwendet wird. Ein Sortieralgorithmus zur Minimierung des Bohrverfahrwegs kann optional aktiviert werden. Durch einfache Änderung einer Compiler-Direktive kann das Programm so übersetzt werden, dass es bei der Bohrdatenausgabe eine grafische Anzeige des Bohrverfahrwegs generiert (Bohrverfahrweg-Simulation).

DUMPPLC (LAY) -- Platzierungsdatenausgabe

Das Programm dumpplc.ulc gibt die Platzierungsdaten des aktuell geladenen Layouts auf Datei aus, wobei zwischen generischem Format und BAE-Format gewählt werden kann. Bei der Ausgabe im BAE-Format kann wahlweise eine Rundung der Platzierungskoordinaten auf das aktuell eingestellte X-Eingaberaster veranlasst werden.

EDF20CON (LAY) -- EDIF 2.0 Netzliste importieren

Das Programm edf20con.ulc dient der Übernahme von EDIF-Netzlisten in den Bartels AutoEngineer. edf20con liest die selektierte EDIF-Datei mit der Dateinamensendung .edn und speichert die eingelesene Netzliste in einer DDB-Datei unter dem in der Eingabedatei für die Netzliste angegebenen Elementnamen (der über LAYDEFELEMENT mit dem Utilityprogramm bsetup gesetzte Name wird verwendet, wenn kein Elementname in der Eingabedatei spezifiert ist). Für Konsistenzprüfungen wird der Zugriff auf die Pinlisten der in der Netzliste verwendeten Bauteilsymbole benötigt. Die entsprechenden Layoutsymbolinformationen werden entweder aus der Zielprojektdatei oder aus der aktuell selektierten Layoutbibliothek geladen. Erforderliche Bauteile, die noch nicht in der Projektdatei existieren, werden automatisch aus der Layoutbibliothek übernommen. edf20con generiert automatisch die für den nachfolgenden Packager-Lauf benötigten logischen Bibliotheksdefinitionen (1:1-Zuordnung der Bauteilgehäusezuweisungen). Während der Netzlistenumsetzung werden Statushinweise und ggf. Warnungen und Fehlermeldungen auf dem Bildschirm ausgegeben und zusätzlich in die Logdatei bae.log geschrieben. Nach erfolgreicher Übernahme der Netzliste gibt edf20con den Hinweis, dass vor der Weiterbearbeitung im Layout ein Packager-Lauf zur Umsetzung der eingelesenen logischen Netzliste notwendig ist.

Warnung

edf20con ist nur für EDIF-Netzlisten aus ORCAD getestet. Zur Übernahme von EDIF-Netzlisten aus anderen Schaltplanpaketen ist edf20con möglicherweise entsprechend anzupassen.

GENCAD (LAY) -- GENCAD 1.4 Layout Datenausgabe

Das Programm gencad.ulc erzeugt aus dem aktuell geladenen Layout ein Datenfile im Format GENCAD1.4 DAT.

HYPLYNX (LAY) -- HyperLynx Layout Simulationsdatenausgabe

Das Programm hyplynx.ulc erzeugt aus dem aktuell geladenen Layout eine HyperLynx (.HYP) Simulationsdatendatei. Der Lagenaufbau wird aus einer selektierbaren externen Datei mit der Dateinamenserweiterung .stk entnommen. Unregelmäß geformte Lötaugen werden in umschreibende Rechtecke umgewandelt. Die Signallage 1 wird als BOTTOM ausgegeben. Die aktuell als oberste Lage definierte Signallage wird als TOP ausgegeben. Innenlagen (Lage 2 bis Oberste Lage - 1) werden als Inner_Layer_n (mit n im Bereich von 2 bis Oberste Lage - 1) ausgegeben.

ICAPNET (LAY) -- ICAP-Netzlistenimport

Das Programm icapnet.ulc importiert gepackte (d.h. physikalische) Netzlisten aus dem Schaltplan-/Simulationstool ICAP/4 (Version 8.2.10 / 1843 oder neuer; Tango-Netzlisten-Export) der Firma Intusoft. icapnet liest die Netzlistendaten aus der selektierten Netzlistendatei project.net und speichert die Netzliste in der DDB-Datei project.ddb unter dem in der Netzlistendatei angegebenen Elementnamen für die Netzliste (default netlist) ab. icapnet generiert 1:1-Pinzuweisungen für Bauteile ohne logische Bibliotheksdefinitionen in der Standard-Layoutbibliothek. Hinweise, Warnungen und Fehlermeldungen über den Fortgang der Netzlistenumsetzung werden auf dem Bildschirm und in der Logdatei bae.log aufgelistet. Nach erfolgreicher Übernahme der logischen Netzliste startet icapnet automatisch den Packager welcher seinerseits die logische Netzliste in eine physikalische Netzliste mit Pin- und Gattertauschinformation entsprechend der logischen Bibliotheksdefinitionen für die weitere Bearbeitung im Layout umwandelt.

IPCOUT (LAY) -- IPC-D-356 Testdatenausgabe

Das Programm ipcout.ulc generiert für das aktuell geladene Layout eine Testdatenausgabe im Format IPC-D-356. Die Ausgabe erfolgt auf eine Datei. Durchkontaktierungen werden als Zentrumspunkte behandelt. Lötmaskendaten werden aus der Dokumentarlage 2 extrahiert. Die Ausgabe wird nach Netzen bzw. Bohrungen sortiert und enthält bohrklassenspezifische Kontaktierungsvorgaben. Am Ende der Ausgabedatei wird eine Zählstatistik für die PIns, Durchkontaktierungen und Bohrungen ausgegeben.

LAYDUMP (LAY) -- Layout-ASCII-Dump Ein-/Ausgabe

Das Programm laydump.ulc bietet Funktionen zur Eingabe und Ausgabe von Layoutelementdaten in einem generischen, für BNF-Parser geeigneten ASCII-Format an. Die Ausgabefunktion gibt einen ASCII-Dump des aktuell geladenen Layoutelements auf Datei aus, wobei unterschiedliche Längeneinheiten für die Ausgabe zur Auswahl stehen.

Hinweis

Die Ausgabefunktion ist in allen Layoutmodulen, die Eingabefunktion jedoch nur im Layouteditor verfügbar.

LAYDXFDO (LAY) -- Layout AutoCAD/DXF-Ausgabe

Das Programm laydxfdo.ulc erzeugt eine AUTOCAD-DXF-Ausgabe für das aktuell geladene Layoutelement. Es steht ein Menü zur Selektion der auszugebenden lagen zur Verfügung. Alternativ können auch die aktuell sichtbaren oder programmintern definierte lagen ausgegeben werden.

LAYEPS (LAY) -- Layout EPS/PDF Ausgabe

Das Programm layeps.ulc erzeugt für das aktuell geladene Layoutelement wahlweise eine Ausgabe im Adobe Portable Document Format (PDF) oder im Encapsulated PostScript (EPS) Format, wobei verschiedene Ausgabeformate und Skalierungsmodi zur Auswahl stehen. Es werden mehrere Lagen simultan geplottet, wobei für jede Lage zusätzlich Ausgabeoptionen für Füllmodus, Farb- bzw. Grauwert, Schraffur, gestrichelte Linien und Linienstärken spezifiziert werden können. Die auszugebenden Lagen sowie die Ausgabeoptionen sind in einer - an firmenspezifische Konventionen anpaßbaren - speziellen Variablen im Quellcode von layeps festgelegt. Wahlweise können auch menüselektierbare Lagen oder die aktuell sichtbaren Lagen mit Farbauswahl bzw. Farbzuweisung oder automatischer Grauwertskalierung der aktuellen Farben geplottet werden. Das Programm unterstützt die aus dem CAM-Prozessor bekannten Spiegelungsoptionen. Über eine weitere Option kann ein interaktiv festlegbarer Bereich für die Ausgabe selektiert werden.

LAYERUSE (LAY) -- Layoutbibliothek Lagenbelegungsreport

Das Programm layeruse.ulc ist ein Utilityprogramm für das Layout-Bibliotheksmanagement. layeruse.ulc analysiert die Lagenbelegung einer selektierbaren DDB-Datei und gibt das Ergebnis dieser Analyse in Form eines Reports auf eine ASCII-Datei aus.

LAYPCR (LAY) -- Layout-Report

Das Programm laypcr.ulc zeigt einen Report über das aktuell geladene Layoutelement in einem Popupmenü mit Ausgabeoption an.

LAYZMBRD (LAY) -- Zoom auf Layout-Platinenumrandung

Das Programm layzmbrd.ulc führt einen Zoom auf die Layout-Platinenumrandung aus.

LBROWSE (LAY) -- Layoutsymbolbrowser

Das Programm lbrowse.ulc ermöglicht die Auswahl zu ladender bzw. zu platzierender Layoutbibliothekselemente, wobei in einem Popupmenü eine grafische Voranzeige des aktuell selektierten Bibliothekselements erfolgt.

LCIFOUT (LAY) -- Layout CIF-Datenausgabe

Das Programm lcifout.ulc generiert Caltech-CIF-Daten aus dem aktuell geladenen Layoutelement. Über einen Dialog können der Name der Ausgabedatei spezifiziert, alle oder nur gruppenselektierte Elemente zur Ausgabe ausgewählt und der CIF-Ausgabemodus (flach oder hierarchisch) selektiert werden.

LDEFMANG (LAY) -- Platzierungsvorgaben fuer Layoutbauteilmakros definieren

Das Programm ldefmang.ulc ermöglicht die Zuweisung von Platzierungsvorgaben (z.B. für Drehung und Spiegelung) aus dem Neuronalen Regelsystem an das aktuell geladenen Layout-Bibliothekselement. Diese Vorgaben werden von den entsprechenden BAE-Platzierungsfunktionen automatisch berücksichtigt. Um undefinierte Regelsystemfehler zu vermeiden, sollten Regeln mit den Bezeichnungen rot0, rot90, rot180, rot270, mirroroff und mirroron mit Hilfe des Regelsystemcompilers rulecomp definiert sein (die mitgelieferte Quellcodedatei partplc.rul enthält die benötigten Regeldefinitionen).