„COBOL“ – Versionsunterschied
[ungesichtete Version] | [gesichtete Version] |
FlaBot (Diskussion | Beiträge) K robot Ergänze:he,ia,uk,ko Ändere:cs |
Linkvorschlag-Funktion: 2 Links hinzugefügt. |
||
(525 dazwischenliegende Versionen von mehr als 100 Benutzern, die nicht angezeigt werden) | |||
Zeile 1: | Zeile 1: | ||
{{Infobox Programmiersprache |
|||
|Name = COBOL |
|||
in der Frühzeit der Computerei nach dem zweiten Weltkrieg entstanden ist und |
|||
|Logo = |
|||
eine für diese Branche ungewöhnliche Überlebensfähigkeit bis in |
|||
|Beschreibung= |
|||
die heutige Zeit hinein bewiesen hat. |
|||
|Paradigma=Zunächst rein imperativ, später erweitert um Elemente der [[Strukturierte Programmierung|strukturierten]], [[Prozedurale Programmierung|prozeduralen]] und heutzutage sogar [[Objektorientierung|objektorientierten]] Programmierung |
|||
|Erscheinungsjahr = 1959 |
|||
|Entwickler= [[Grace Hopper]], [[William Selden (Informatiker)|William Selden]], [[Gertrude Tierney]], [[Howard Bromberg]], [[Howard Discount]], [[Vernon Reeves]], [[Jean E. Sammet]] |
|||
|AktuelleVersion = |
|||
|AktuelleVersionFreigabeDatum = |
|||
|Typisierung = [[Starke Typisierung|stark]], [[Statische Typisierung|statisch]] |
|||
|Implementierung = |
|||
|Dialekte = DEC COBOL, HP COBOL, IBM OS/VS COBOL, IBM COBOL/II, IBM COBOL SAA, IBM Enterprise COBOL, IBM COBOL/400, IBM ILE COBOL, Unix COBOL X/Open, Micro Focus COBOL, Microsoft COBOL, Ryan McFarland RM/COBOL, Ryan McFarland RM/COBOL-85, DOSVS COBOL, UNIVAC COBOL, Realia COBOL, Fujitsu COBOL, [[ACUCOBOL|ACUCOBOL-GT]] |
|||
|Beeinflusst_von = [[FLOW-MATIC]], [[COMTRAN]], FACT |
|||
|Beeinflusste = [[PL/I]], [[PL/SQL]], [[ABAP]] |
|||
|Betriebssystem = [[z/OS]], [[Microsoft Windows|Windows]], [[Linux]], [[Mac OS X]], [[BS2000]], [[OS/400]] u. v. m. |
|||
|Lizenz = |
|||
|Website = |
|||
}} |
|||
'''COBOL''' ist eine [[Programmiersprache]], die in der Frühzeit der Computerentwicklung, Ende der [[1950er]]-Jahre, entstand und bis heute verwendet wird.<ref>{{Internetquelle |autor=Martin Reusch |url=https://www.it-daily.net/it-management/business-software/cobol-2022-so-relevant-wie-nie |titel=COBOL 2022 – So relevant wie nie?! |werk=it-daily.net |datum=2022-04-11 |sprache=de |abruf=2023-08-15}}</ref> Der Stil dieser Programmiersprache ist stark an die [[natürliche Sprache]] angelehnt und dient vor allem der Programmierung kaufmännischer Anwendungen. |
|||
Die Abkürzung |
|||
COBOL steht für "'''Co'''mmon '''B'''usiness '''O'''riented |
|||
'''L'''anguage". |
|||
==Geschichte== |
|||
Cobol entstand aus dem dringenden Wunsch, eine hardware-unabhängige standardisierte |
|||
problemorientierte Sprache für die Erstellung von Programmen |
|||
für den betriebswirtschaftlichen Bereich zu haben. |
|||
Eine vom amerikanischen Verteidigungsministerium eingesetzte Arbeitsgruppe entwickelte |
|||
einen Standard aus der Vermählung der damaligen Programmiersprachen ''FLOW-MATIC'' |
|||
von Sperry Univac (Remington-Rand), ''Commercial Translator'' (COMTRAN) von [[IBM]]. und ''FACT'' von Minneapolis-Honeywell. |
|||
Namentlich beteiligt hieran war eine Frau: [[Grace Hopper|Grace M. Hopper]]. |
|||
Die Abkürzung COBOL steht für „'''Co'''mmon '''B'''usiness '''O'''riented '''L'''anguage“.<ref name=":0">{{Internetquelle |autor=Kathrin Stoll |url=https://t3n.de/news/senior-programmer-haenderingend-1271123/ |titel=Senior Programmer händeringend gesucht – für 60 Jahre alte Programmiersprache – t3n – digital pioneers |abruf=2020-04-23 |sprache=de-DE}}</ref> |
|||
Das Ergebnis ist dann 1960 als Cobol-60 von [[CODASYL]] verabschiedet worden und |
|||
in der Folgezeit weiterentwickelt und von nationalen und internationalen |
|||
Normierungsinstituten (ANSI, ISO) standardisiert worden. |
|||
== Geschichte == |
|||
COBOL fand schnell den Weg in die zivile Nutzung |
|||
COBOL entstand aus dem dringenden Wunsch, eine hardwareunabhängige, standardisierte, problemorientierte Sprache für die Erstellung von Programmen für den betriebswirtschaftlichen Bereich anwenden zu können. Die Programmierung kaufmännischer Anwendungen unterscheidet sich von technisch-wissenschaftlichen Anwendungen vor allem durch die Handhabung großer [[Datenverarbeitung|Datenmengen]] statt der Ausführung umfangreicher Berechnungen. Nachdem die Programmierung technisch-wissenschaftlicher Anwendungen durch [[FORTRAN]] bereits sehr vereinfacht worden war, sollte die neue Programmiersprache kaufmännische Problemstellungen, insbesondere die Handhabung großer Datenmengen und deren Ein- und Ausgabe stärker unterstützen – wozu bis dahin weitgehend [[Assemblersprache]]n verwendet wurden. |
|||
als eine der ersten kommerziell eingesetzten kompilierbaren |
|||
und bis heute am weitesten verbreiteten Programmiersprachen, vor allem für kommerzielle Anwendungen. |
|||
Eine vom amerikanischen Verteidigungsministerium eingesetzte Arbeitsgruppe entwickelte einen Standard aus der Verbindung der damaligen Programmiersprachen ''[[FLOW-MATIC]]'' von [[Sperry Rand|Sperry Univac]] (Remington-Rand), ''Commercial Translator'' (COMTRAN) von [[IBM]] und ''FACT'' von Minneapolis-Honeywell. |
|||
==Sprachsyntax== |
|||
Namentlich beteiligt hieran war [[Grace Hopper|Grace M. Hopper]], die bereits [[FLOW-MATIC]] sowie den ersten [[Compiler]] ([[A-0]]) entwickelt hatte.<ref>{{Webarchiv | url=http://www1.wdr.de/kultur/kunst/ada-102.html | wayback=20160608215204 | text=WDR}}</ref><ref>[https://marcgg.com/blog/2015/02/02/grace-murray-hopper-technical/ Grace Hopper], aufgerufen am 8. Juni 2016</ref> |
|||
COBOL zeichnet sich aus durch eine strikte Trennung von Datendeklaration und prozeduralen Anweisungen. Im Prozedurteil kann man nur Variablen benutzen, die vorher im Datenteil deklariert worden sind. Auch das Aussehen von formatierten Ausgaben wird nicht im Prozedurteil, sondern im Datenteil durch die PICTURE-Klausel festgelegt. Der "REPORT WRITER" macht es möglich, die Struktur einer Druckliste komplett im Datenteil als physische Struktur von Seiten, und logische Struktur von Postenzeilen mit Gruppensummen etc zu beschreiben, ohne dass sich der Prozedurteil darum kümmern muss. |
|||
Das Ergebnis wurde 1960 als COBOL-60 von [[CODASYL]] verabschiedet, in der Folgezeit weiterentwickelt und von nationalen und internationalen Normierungsinstituten (ANSI, ISO) standardisiert. |
|||
Ein COBOL-Programm ist in Teile (DIVISION), Kapitel (SECTION) und Abschnitte (PARAGRAPH) gegliedert. |
|||
Die vier DIVISIONs sind in ihrer festgelegten Reihenfolge: |
|||
*''Identification Division'' mit dem Programmnamen und einigen weitgehend obsoleten Paragraphen für Kommentare; |
|||
*''Environment Division'', wo Schnittstellen zum Betriebs- und dessen Dateisystem definiert werden; |
|||
*''Data Division'' mit der Definition der Programmvariablen und Datenstrukturen |
|||
*''Procedure Division'' mit den prozeduralen Anweisungen. |
|||
COBOL fand schnell den Weg in die zivile Nutzung als eine der ersten kommerziell eingesetzten kompilierbaren Programmiersprachen und ist bis heute eine der am weitesten verbreiteten für kaufmännische Anwendungen. |
|||
In der IDENTIFICATION DIVISION gibt es keine SECTIONs, und in der PROCEDURE DIVISION können neuerdings SECTIONS und auch Paragraphs entfallen. ENVIRONMENT und DATA DIVISIONs können u.U. ganz entfallen. |
|||
2020 entstand in den USA noch einmal Nachfrage nach COBOL-Entwicklern, als im Zuge der [[COVID-19-Pandemie|Corona-Pandemie]] die Arbeitslosenzahlen sprunghaft anstiegen, aber die Verwaltungssysteme der Arbeitslosenversicherung im US-Bundesstaat [[New Jersey]] der Nachfrage nicht mehr gewachsen waren.<ref name=":0" /><ref>[https://www.derstandard.at/story/2000116578243/covid-19-warum-in-den-usa-ploetzlich-wieder-cobol-programmierer "Covid-19: Warum in den USA plötzlich wieder Cobol-Programmierer gebraucht werden"] der Standard vom 6. April 2020</ref> |
|||
Das traditionelle Kodierschema bei Cobol entspricht der [[Lochkarte]] mit ihren 80 Spalten, d. h. Schreibstellen. |
|||
Dabei waren reserviert |
|||
*die ersten 6 Stellen für Zeilennummerierungen |
|||
*Spalte 7 zur Kennzeichnung einer Kommentar- oder einer Fortsetzungszeile oder einer, die nur für Debugging übersetzt werden soll |
|||
*Spalte 73 bis 80 für sonstige Markierungen wie z.B. den Namen von Programm oder Sourceelement |
|||
*Spalte 8 bis 11 für die Namen von Divisions, Sections und Paragraphs. |
|||
== Sprachsyntax == |
|||
Der aktuelle Standard (2002) kennt ein fixes Zeilenformat, wo die rechte Randbegrenzung aufgehoben ist, und ein ganz freies Format, wo auch die Einteilung der ersten 12 Spalten aufgegeben ist. |
|||
Ursprünglich wurde COBOL nur in Großbuchstaben geschrieben, da nur [[Lochkarte]]n und Zeilendrucker ohne Kleinbuchstaben zur Verfügung standen. Auch heute wird nicht zwischen Groß- und Kleinschreibung unterschieden. COBOL ist somit ''[[case insensitive]]''. |
|||
Ein COBOL-Programm ist in Teile (<code>DIVISION</code>), Kapitel (<code>SECTION</code>) und Abschnitte (<code>PARAGRAPH</code>) gegliedert. |
|||
Die vier <code>DIVISION</code>s sind in ihrer festgelegten Reihenfolge: |
|||
Ursprünglich wurde COBOL nur in Großbuchstaben geschrieben (man hatte nur Lochkarten und Zeilendrucker ohne Kleinbuchstaben), heute können Variablen und COBOL-Anweisungen beliebig groß oder klein geschrieben werden. Die Sprache ist nicht ''case-sensitive'': |
|||
* <code>Identification Division</code> mit dem Programmnamen und einigen weitgehend obsoleten Paragraphen für Kommentare; |
|||
* <code>Environment Division</code>, in der Schnittstellen zum Betriebs- und dessen [[Dateisystem]] definiert werden; |
|||
* <code>Data Division</code> mit der Definition der Programmvariablen und Datenstrukturen und |
|||
* <code>Procedure Division</code> mit den prozeduralen Anweisungen. |
|||
In der <code>IDENTIFICATION DIVISION</code> gibt es keine <code>SECTION</code>s, und in der <code>PROCEDURE DIVISION</code> können neuerdings <code>SECTION</code>s und auch <code>PARAGRAPH</code>s entfallen. <code>ENVIRONMENT</code> und <code>DATA DIVISION</code>s können unter Umständen ganz entfallen. |
|||
Ein fast minimales Cobol-Programm: |
|||
Hieran sieht man die strikte Trennung von Datendeklaration und prozeduralen Anweisungen, durch die sich COBOL auszeichnet. Im Prozedurteil kann man nur Variablen benutzen, die vorher im Datenteil deklariert worden sind. Auch das Aussehen von formatierten Ausgaben wird nicht im Prozedurteil, sondern im Datenteil durch die <code>PICTURE</code>-Klausel festgelegt. Der <code>REPORT WRITER</code> macht es möglich, die Struktur einer Druckliste komplett im Datenteil als physische Struktur von Seiten und logische Struktur von Postenzeilen mit Gruppensummen etc. zu beschreiben, ohne dass sich der Prozedurteil darum kümmern muss. |
|||
=== Kodierung === |
|||
Das traditionelle Kodierschema bei COBOL entspricht der [[Lochkarte]] mit ihren 80 Spalten, d. h. Schreibstellen. |
|||
Dabei waren die ersten 6 Stellen für die Zeilennummerierungen reserviert. Spalte 7 wurde zur Kennzeichnung einer Kommentar- oder einer Fortsetzungszeile beziehungsweise einer, die nur für das Debugging übersetzt werden soll, reserviert. Spalte 8 bis 11 (''Area A'') beinhaltete die Namen von Divisions, Sections und Paragraphs. Die 12. bis 72. Spalte (''Area B'') beherbergten alles übrige, zum Beispiel Anweisungen (''statements''). Spalte 73 bis 80 waren für sonstige Markierungen wie z. B. den Namen des Programms oder Quelltext-Elementen vorgesehen. |
|||
Die Standards ab 2002 kennen neben dem fixen Zeilenformat, das die Einteilung in Area A und Area B aufhebt, ein ganz freies Format, das in den Spalten 1 bis 255 alles erlaubt. Die Sonderrolle der Spalte 7 entfällt, da Kommentare mit <code>*></code> eingeleitet, [[Literal]]e mittels <code>&</code> zusammengesetzt und [[Debugger|Debuggingzeilen]] mittels bedingter Übersetzung realisiert werden <code>>>DEFINE … >>IF …</code>. |
|||
Ein fast minimales COBOL-Programm: |
|||
<syntaxhighlight lang="COBOL"> |
|||
Identification Division. |
Identification Division. |
||
Program-ID. HALLOPGM. |
Program-ID. HALLOPGM. |
||
Procedure Division. |
Procedure Division. |
||
Display "Hallo |
Display "Hallo Welt!". |
||
STOP RUN. |
|||
</syntaxhighlight> |
|||
===Datendeklarationen=== |
=== Datendeklarationen === |
||
… erfolgen in der ''Data Division'' |
|||
*Dateien und deren Satzstrukturen werden in der ''File Section'' beschrieben. |
* Dateien und deren Satzstrukturen werden in der ''File Section'' beschrieben. |
||
* |
* Statische (globale) [[Variable (Programmierung)|Variablen]] werden in der ''Working-Storage Section'' definiert. |
||
* |
* Automatische (lokale bzw. dynamische) [[Variable (Programmierung)|Variablen]] werden in der ''Local-Storage Section'' definiert (siehe [[Stapelspeicher|Stack]]). |
||
* |
* Aufruf-Parameter werden in der <code>Linkage Section</code> definiert. |
||
* |
* Komplexe Drucklisten werden in der <code>Report Section</code> definiert. |
||
* Bildschirmein- und -ausgabe in der <code>Screen Section</code>. |
|||
Zur Deklaration von Variablen bietet COBOL zahlreiche Klauseln, deren wichtigsten die Stufennummer, |
Zur Deklaration von Variablen bietet COBOL zahlreiche Klauseln, deren wichtigsten die Stufennummer, die PICTURE-Klausel und die USAGE-Klausel sind. |
||
;Stufennummer: |
|||
Die Stufennummer 77 kennzeichnet eine freistehende Variable, 01 kann ebenfalls eine freistehende Variable bezeichnen, leitet aber normalerweise die Deklaration einer Gruppe ein, was in anderen Sprachen als ''Record'' ([[Pascal (Programmiersprache)|Pascal]] u.ä.) oder ''struct'' ([[C_(Programmiersprache)|C]]/[[C-Plusplus |C++]] u.ä.) bezeichnet wird. Die Stufennummern 02 bis 49 kennzeichnen dann dieser Gruppe untergeordnete Datendeklarationen, die selber auch wieder Gruppen (Records) sein können. Eine Datendeklaration, die keine weiteren untergeordneten (mit höheren Stufennummern) Datendeklarationen hat, wird in COBOL als elementar (''elementary Item'') bezeichnet, ansonsten ist es eine Gruppen-Variable (''Group Item''). Eine solche Gruppe kann man abstrakt als Baum darstellen mit den Gruppen als Knoten und den ''elementary Items'' als Blättern. |
|||
Die Stufennummer 77 kennzeichnet eine freistehende Variable. Die Stufennummer 01 kann ebenfalls eine freistehende Variable bezeichnen, leitet aber normalerweise die Deklaration einer Gruppe ein – was in anderen Sprachen als ''Record'' ([[Pascal (Programmiersprache)|Pascal]] u. ä.) oder ''struct'' ([[C++]], [[C (Programmiersprache)|C]] u. ä.) bezeichnet wird. Die Stufennummern 02 bis 49 kennzeichnen dann dieser Gruppe untergeordnete Datendeklarationen, die selber auch wieder Gruppen sein können. Eine Datendeklaration, die keine untergeordneten Datendeklarationen (d. h. mit höheren Stufennummern) hat, wird in COBOL als elementar ''(elementary item)'' bezeichnet, anderenfalls ist es eine Gruppen-Variable ''(group item)''. Derartige Datendeklarationen kann man abstrakt als [[Baum (Datenstruktur)|Baum]] darstellen; mit den Gruppen als Knoten und den ''elementary items'' als Blättern – denen über die PIC-Klausel Datenformate zugeordnet sind. |
|||
Mit der speziellen Stufennummer 66 kann man ganzen Speicherbereichen einen anderen Namen geben, mit 88 |
Mit der speziellen Stufennummer 66 kann man ganzen Speicherbereichen einen anderen Namen geben, mit 88 einen Bedingungsnamen definieren, der wie ein boolescher Ausdruck in zum Beispiel einer IF-Anweisung verwandt werden kann. |
||
Die Stufennummern werden üblicherweise zweistellig geschrieben. Aus den Lochkartenzeiten stammt die Gewohnheit, die Stufennummern in einer Gruppendefinition nicht fortlaufend, sondern in Schritten von 5 oder 10 zu vergeben, weil man dann Zwischenstufen einfügen konnte, ohne gleich einen ganzen Kartenstapel neu lochen zu müssen. |
Die Stufennummern werden üblicherweise zweistellig geschrieben. Aus den Lochkartenzeiten stammt die Gewohnheit, die Stufennummern in einer Gruppendefinition nicht fortlaufend, sondern in Schritten von 5 oder 10 zu vergeben, weil man dann Zwischenstufen einfügen konnte, ohne gleich einen ganzen Kartenstapel neu lochen zu müssen. |
||
Das folgende Beispiel beschreibt das Layout der traditionellen 80-stelligen COBOL-Programmzeile: |
Das folgende Beispiel beschreibt das Layout der traditionellen 80-stelligen COBOL-Programmzeile: |
||
<syntaxhighlight lang="cobolfree"> |
|||
01 Cobol-Zeile USAGE DISPLAY. |
01 Cobol-Zeile USAGE DISPLAY. |
||
05 Zeilennummer PIC 9(6). |
05 Zeilennummer PIC 9(6). |
||
05 Indikator PIC X. |
05 Indikator PIC X. |
||
88 Ist-Kommentar VALUES '*' '/'. |
|||
88 Ist-Fortsetzungszeile VALUE '-'. |
|||
88 Ist-Debuggingzeile VALUE 'D' 'd'. |
|||
05 Bereich-A-und-B. |
05 Bereich-A-und-B. |
||
10 Bereich-A PIC X(4). |
10 Bereich-A PIC X(4). |
||
10 Bereich-B PIC X(61). |
10 Bereich-B PIC X(61). |
||
05 Zeilen-Endekennung PIC X(8). |
05 Zeilen-Endekennung PIC X(8). |
||
</syntaxhighlight> |
|||
Die Definition eines Wertebereiches sieht als Beispiel so aus: |
Die Definition eines Wertebereiches sieht als Beispiel so aus: |
||
<syntaxhighlight lang="cobolfree"> |
|||
01 Wertebereich PIC 99V99 USAGE COMPutational. |
|||
01 Wertebereich PIC 99V99 USAGE COMPUTATIONAL. |
|||
88 |
88 Einerwerte Value 1 thru 9. |
||
88 |
88 Zehnerwerte Value 10 thru 19. |
||
88 Zwanzigerwerte Value 20 thru 29. |
|||
</syntaxhighlight> |
|||
;Internes und Externes Datenformat: |
|||
Äußere Erscheinung und interne Repräsentation werden im wesentlichen durch die Klauseln PICTURE und USAGE bestimmt. . USAGE COMP, wenn damit gerechnet werden soll, DISPLAY zur Anzeige. Die Symbole hinter PICture legen die Anzahl Stellen oder Zeichen fest, bzw. Editiersymbole wie Dezimal- oder Tausendertrennzeichen, Vorzeichen, Währungssymbole, gedachtes Dezimaltrennzeichen (V) etc., und bestimmen eine elementare Variable damit als entweder alphabetisch, alphanumerisch, numerisch oder numerisch-editiert. |
|||
Äußere Erscheinung und interne Repräsentation werden im Wesentlichen durch die Klauseln <code>PICTURE</code> und <code>USAGE</code> bestimmt. Mit <code>USAGE COMP</code> werden binäre Rechen- und Vergleichsoperationen ausgeführt, <code>USAGE DISPLAY</code> dient zur Anzeige. Arithmetische Operationen und Vergleiche (kleiner/gleich/größer …) sind mit <code>USAGE COMP-3</code> direkt möglich. |
|||
Mit Angaben hinter <code>PICTURE</code> wird die Anzahl der Stellen/Zeichen oder auch Editiersymbole wie Dezimal- oder Tausendertrennzeichen, Vorzeichen, Währungssymbole, gedachtes Dezimaltrennzeichen (V) etc. festgelegt. Sie bestimmen eine elementare Variable damit als entweder alphabetisch, alphanumerisch, numerisch oder numerisch-editiert. Sind für arithmetische Operationen (wie <code>ADD BETRAG-X to SUMME-Y</code> oder <code>IF DATUM-A > DATUM-B)</code> Variablen mit uneinheitlichen numerischen Formaten beteiligt, so wird vor der Operation automatisch eines oder beide der Datenfelder in ein (für die Operation) gültiges Format konvertiert. |
|||
In COBOL wird die Formatierung für sichtbare Ausgabe eben durch die Datendeklaration erledigt, nicht durch prozedurale Anweisungen wie in Sprachen wie Pascal oder C. Den Rest der insgesamt etwa 60 möglichen Klauseln einer Datendeklaration möge man in einem COBOL-Handbuch nachschlagen. |
|||
Die Formatierung für sichtbare Ausgaben wird durch die Datendeklaration bestimmt, nicht durch prozedurale Anweisungen wie in Sprachen wie Pascal oder C. Weitere der insgesamt etwa 60 möglichen Klauseln einer Datendeklaration möge man in einem COBOL-Handbuch nachschlagen. |
|||
===Prozedurale Anweisungen=== |
|||
In der ''Procedure Divsion'' findet sich der ausführbare Programmcode. Die Ausführung beginnt mit der ersten Anweisung in hinter der Überschrift '''Procedure Division''' bzw. den ''DECLARATIVES'', deren Ausführung nur durch bestimmte Ereignisse ausgelöst wird. Danach werden alle Anweisungen sequentiell ausgeführt, bis ein STOP RUN das Programm beendet, oder ein GO TO zu einer anderen Stelle im Programm verzweigt. |
|||
;Tabellenformate: |
|||
Die Procedure Divsion besteht aus einer oder mehreren Prozeduren. |
|||
Mehrfach auftretende Daten (in COBOL ‚Tabellen‘ genannt, siehe [[Feld (Datentyp)]]) werden durch die <code>OCCURS</code>-Klausel definiert; Beispiel für eine mehrdimensionale Tabelle: |
|||
05 PRODUKT OCCURS 100. |
|||
10 PRODUKTNR PICTURE 999. |
|||
10 PRODUKTNAME PICTURE X(30). |
|||
10 PREIS PICTURE 999V99 OCCURS 5 INDEXED BY IND_KUNDENGRUPPE. |
|||
Die Occurs-Klausel ist sowohl je Datengruppe als auch für Elementarfelder möglich. Die Adressierung der jeweiligen Dimension kann alternativ durch die Index-Methode (Zusatz <code>Indexed BY <IND-NAME></code>) oder durch ein Subscript erfolgen: |
|||
* Ein ‚Subscript‘ ist der Name einer (numerischen) Variable im jeweiligen COBOL-Befehl (Beispiel: <code>MOVE PRODUKTNR (PNR) TO xx</code>). |
|||
* Ein ‚Index‘ enthält die Distanz der zu adressierenden Datendimension zum Beginn der Tabelle und wird mit einem SET-Befehl explizit auf diesen Wert eingestellt: <code>SET IND_KUNDENGRUPPE BY KUNDENGRP</code>. Die Indizierung ist vorteilhaft, wenn sich mehrere/viele Einzelbefehle auf die zu adressierende Dimension beziehen, weil der wesentliche Teil der Adressberechnung nicht je Befehlsausführung, sondern bei ''SET'' erfolgt. |
|||
Die Maschinenbefehle zur Berechnung des Abstands der durch Index/Subscript adressierten Dimension zum Anfang der Tabelle {z. B. (PNR-1)*Länge(Datengruppe PRODUKT)} werden in beiden Versionen automatisch dem eigentlichen COBOL-Befehl (MOVE, IF usw.) vorangestellt und ausgeführt. In mehrdimensionalen Tabellen (siehe Beispiel) können beide Adressierungsmethoden gemischt angewendet werden. |
|||
Mit dem Zusatz <code>DEPENDING ON xxx</code> kann die Anzahl der Tabellenelemente variabel definiert werden. |
|||
=== Prozedurale Anweisungen === |
|||
In der <code>Procedure Division</code> findet sich der ausführbare Programmcode. Die Ausführung beginnt mit der ersten Anweisung hinter der Überschrift <code>Procedure Division</code> bzw. den <code>DECLARATIVES</code>, deren Ausführung nur durch bestimmte Ereignisse ausgelöst wird. Danach werden alle Anweisungen sequentiell ausgeführt, bis ein <code>STOP RUN</code> das Programm beendet, oder ein <code>GO TO</code> bzw. <code>PERFORM</code> (mit anschließender Rückkehr) zu einer anderen Stelle im Programm verzweigt. |
|||
Die Procedure Division besteht aus einer oder mehreren Prozeduren. |
|||
Eine Prozedur ist entweder |
Eine Prozedur ist entweder |
||
*eine Section: |
* eine Section: Bezeichnet mit einem Namen, der in Spalte 8 beginnt, gefolgt von dem Schlüsselwort <code>SECTION</code> und einem Punkt; enthält meist mehrere Paragraphen. |
||
* ein Paragraph: Bezeichnet mit einem Namen, der in Spalte 8 beginnt und mit Punkt endet. |
|||
*eine Gruppe von Sections |
|||
Eine solche Prozedur enthält die Anweisungen des COBOL-Programms (''Statements''). |
|||
*ein Paragraph: Ein Name, der in Spalte 8 beginnt und mit Punkt endet. |
|||
*eine Gruppe von Paragraphs |
|||
Eine solche Prozedur besteht dann aus einem oder mehreren Cobol-Anweisungen (''Statements''). |
|||
Prozeduren können mit der |
Prozeduren können mit der COBOL-Anweisung <code>Perform</code> von anderen Stellen im Programm aus ausgeführt/aufgerufen werden. Durch den Zusatz <code>THRU <proz-name></code> in der Perform-Anweisung können mehrere Prozeduren zur Ausführung zusammengefasst werden. Es gibt keine formale Parameterübergabe, alle Prozeduren haben Zugriff auf alle Felder in der Data Division. |
||
Mittels |
Mittels <code>CALL</code> können externe Programme (COBOL oder andere Programmiersprachen) aufgerufen werden. Dabei werden Parameter ''By Reference'' oder ''By Content'' (je nach COBOL-Version auch ''By Value'' genannt) übergeben, wodurch u. a. unterschieden wird, ob übergebene Parameter-Variablen vom aufgerufenen Programm für das aufrufende Programm wirksam geändert werden können (by ref) oder nicht (by content). |
||
COBOL unterstützt seit dem Standard 1974 (VS COBOL II) die [[strukturierte Programmierung]]; seither ist die Verwendung von ‚GOTO‘ zwar noch möglich, aber verpönt. In der professionellen Programmierung herrschen hausinterne Programmierstandards, welche in der Mehrzahl festlegen, dass Prozeduren ausschließlich aus einer Section bestehen. |
|||
COBOL wurde mit einer an der englischen Sprache angelehnten Syntax entworfen, um ‚selbst-dokumentierend‘ und auch für Nicht-Programmierer im Wesentlichen leicht lesbar zu sein. Alle Anweisungen beginnen mit einem in den ‚COBOL-Schlüsselwörtern‘ reservierten Verb (wie in <code>MOVE x TO y</code>) – im Gegensatz zu Kurznotierungen (wie <code>y = x</code>) in anderen modernen Programmiersprachen. |
|||
Ziel der Cobol-Syntax soll sein, dass auch ein nicht an formale Programmiersyntax gewohnter Mensch den Sinn eines Cobol-Programm erahnen kann (wenn er oder sie denn etwas Englisch kann). Alle Cobol-Anweisungen beginnen mit einem Verb und davon gibt es viele. |
|||
====Einfache Codeschnipsel==== |
|||
Zur Darstellung der Syntax wird einfaches [[C (Programmiersprache)|C]] (oder [[Java (Programmiersprache)|Java]]) zu Hilfe genommen. |
|||
==== Einfache Codeschnipsel ==== |
|||
*Ein ''a = b;'' ist in Cobol ''MOVE b TO a''. |
|||
Zur Darstellung der Syntax wird einfache [[C (Programmiersprache)|C]]-Syntax zu Hilfe genommen. |
|||
*Wenn es z.B. in C heißt ''a = b + c;'', dann schreibt ein Cobol-Programmierer entweder ''ADD b to c GIVING a'' oder alternativ ''COMPUTE a = b + c''. |
|||
*Ein a++; in C entspricht auf Cobol ADD 1 TO a. |
|||
* Eine [[Zuweisung]] <code>a = b</code> in C |
|||
====IF/ELSE und EVALUATE==== |
|||
:entspricht in COBOL <code>MOVE b TO a</code> |
|||
IF und ELSE sind so, wie man es erwartet. |
|||
* Arithmetische [[Ausdruck (Programmierung)|Ausdrücke]] und Zuweisungen: |
|||
:*<code>a = b + c</code> |
|||
::kann in COBOL folgendermaßen geschrieben werden: <code>ADD b TO c GIVING a</code> |
|||
::oder alternativ <code>COMPUTE a = b + c</code> |
|||
:*analog <code>b = a - 1</code> in C |
|||
::entspricht in COBOL <code>SUBTRACT 1 FROM a GIVING b</code> |
|||
* Der [[Inkrement und Dekrement|Inkrementoperator]] <code>++a</code> in C |
|||
:entspricht in COBOL <code>ADD 1 TO a</code> |
|||
* Der Dekrementoperator <code>--a</code> in C |
|||
:entspricht in COBOL <code>SUBTRACT 1 FROM a</code> |
|||
==== IF/ELSE und EVALUATE ==== |
|||
IF und ELSE funktionieren so, wie man es erwartet. Das ''End-If'' wurde erst mit dem COBOL85-Standard eingeführt. Im COBOL74-Standard wurde die IF-Anweisung noch durch einen Punkt beendet, was eine leicht zu übersehende Fehlerquelle darstellen konnte. |
|||
COBOL85-Syntax: |
|||
<syntaxhighlight lang="cobolfree"> |
|||
If Nenner > 0 |
If Nenner > 0 |
||
Compute Zahl = Zaehler / Nenner |
Compute Zahl = Zaehler / Nenner |
||
End-Compute |
|||
Else |
Else |
||
Display " |
Display "Nenner sollte > 0 sein!" |
||
Move 0 To Zahl |
Move 0 To Zahl |
||
End-If |
End-If |
||
</syntaxhighlight> |
|||
COBOL68-Syntax: |
|||
<syntaxhighlight lang="cobolfree"> |
|||
If Nenner > 0 |
|||
Compute Zahl = Zaehler / Nenner |
|||
Else |
|||
Display "Nenner sollte > 0 sein!" |
|||
Move 0 To Zahl. |
|||
</syntaxhighlight> |
|||
EVALUATE macht die mehrfache Fallunterscheidung, womit jede Form von CASE oder Switch (wie in C), Folgen von |
EVALUATE macht die mehrfache Fallunterscheidung, womit jede Form von CASE oder Switch (wie in C), Folgen von IF/ELSIF/ELSIF/END-IF bis hin zu vollständigen [[Entscheidungstabelle]]n dargestellt werden kann. Die Anweisung EVALUATE wurde erstmals in COBOL85 integriert, COBOL-Versionen vor der 85-Version kennen kein EVALUATE, so dass dort mehrfache Fallunterscheidungen über – teils schwierig zu lesende – IF-Konstrukte abgebildet werden mussten. |
||
<syntaxhighlight lang="cobolfree"> |
|||
Evaluate True |
Evaluate True |
||
When Nenner > 0 |
When Nenner > 0 |
||
Zeile 138: | Zeile 193: | ||
Compute Zahl = Zaehler / Nenner * -1 |
Compute Zahl = Zaehler / Nenner * -1 |
||
When Other |
When Other |
||
Display " |
Display "Nenner sollte nicht 0 sein!" |
||
Move 0 To Zaehler |
Move 0 To Zaehler |
||
End-Evaluate |
End-Evaluate |
||
</syntaxhighlight> |
|||
Eine |
Eine COBOL-Spezialität sind die sogenannten ''Conditional Statements'', das sind COBOL-Anweisungen mit einer Bedingungs-Klausel: |
||
COBOL85-Syntax: |
|||
<syntaxhighlight lang="cobolfree"> |
|||
Read Eingabesatz |
Read Eingabesatz |
||
At End |
At End |
||
Display "Dateiende erreicht |
Display "Dateiende erreicht" Eingabe-Zaehler "gelesen!" |
||
Set Ende-der-Verarbeitung To True |
Set Ende-der-Verarbeitung To True |
||
Not At End |
Not At End |
||
Add 1 to Eingabe-Zaehler |
Add 1 to Eingabe-Zaehler |
||
End-read |
End-read |
||
</syntaxhighlight> |
|||
====Schleifen==== |
==== Schleifen ==== |
||
Eine C-Schleife wie |
Eine C-Schleife wie „<code>for (i=0; i<10; ++i) {...}</code>“ wird in COBOL mit PERFORM kodiert (COBOL85-Syntax): |
||
<syntaxhighlight lang="cobolfree"> |
|||
Perform Varying i From 1 By 1 |
|||
Perform Varying i From 0 By 1 |
|||
Until i >= 10 |
|||
... |
|||
End-Perform |
End-Perform |
||
</syntaxhighlight> |
|||
== |
== COBOL heute == |
||
Das Haupteinsatzgebiet der Programmiersprache COBOL ist die betriebswirtschaftliche Datenverarbeitung. Wenn EDV-Programme in eine Benutzerschnittstelle, einen Verarbeitungsteil und einen Datenhaltungsteil strukturiert werden, liegt der Einsatzschwerpunkt von COBOL-Programmen im Verarbeitungsteil. In modernerer Terminologie entspricht COBOL dem [[Frontend und Backend|Backend]]. |
|||
Die Sprache ist an [[Batch]]-Verarbeitung orientiert und enthält z.B. keine |
|||
Elemente, um interaktive Ein/Ausgabe an einem Terminal oder PC |
|||
zu programmieren. Dennoch spielt Cobol problemlos eine große Rolle als Programmiersprache bei der Erstellung von Online-Systemen wie [[CICS]] oder [[IMS]]; solche [[Transaktion_(Informatik)|Transaktionsmonitore]] stellen ihre Dienste mit einem Cobol-tauglichen [[Application Programming Interface|API]] zur Verfügung: Entweder wie z.B. bei [[IMS]] als reines CALL-Interface (CALL 'CBLTDLI') oder wie bei [[CICS]] als EXEC-Sprache, die von einem Preprozessor in Cobol-Code umgesetzt wird. |
|||
Insbesondere auf PCs, aber auch auf anderen Systemen können als Benutzerschnittstelle eine Vielzahl von Möglichkeiten zum Einsatz kommen. Neben den Standard-COBOL-Anweisungen <code>ACCEPT</code> zur Tastatureingabe und <code>DISPLAY</code> zur Bildschirmausgabe kommt aus der X/OPEN-Spezifikation die <code>SCREEN SECTION</code> hinzu, außerdem herstellerspezifische Lösungen. Hiermit lassen sich als Benutzerschnittstelle [[Terminalemulation|Terminals]] programmieren. |
|||
Das gleich gilt für den Zugriff auf relationale Datenbanken: Cobol-Programme benutzen dann [[embedded_SQL|embedded SQL]] (EXEC SQL). Auch kann man [[Stored Procedures]] in Cobol programmieren. |
|||
Sofern die Anwendungsarchitektur in mehrere Schichten getrennt ist, kann die Präsentationsschicht auch auf den Client verlagert werden. Dies erlaubt den Zugriff auf COBOL-Anwendungen über grafische [[Frontend und Backend|Frontends]]. Client und Server müssen dazu ein Kommunikationsprotokoll unterstützen. Musste ein solches ursprünglich manuell entwickelt werden, so stellten später die Architekturmuster der [[serviceorientierte Architektur|SOA]] entsprechende Standards bereit. |
|||
Neuerungen in Cobol aus der jüngsten Zeit: |
|||
*''Nested Program'' erlauben es, innerhalb eines Cobol-Programms Prozeduren mit lokalen Variablen zu schreiben. |
|||
*''Intrinsic Functions'' für mathematische und andere Funktionen. |
|||
*Rekursion bei externen Calls ist möglich. |
|||
*Das Cobol-Verb XML PARSE bietet einen integrierten [[XML]]-Parser. |
|||
*OO-Erweiterungen erleichterten die Zusammenarbeit mit objektorientierten Menschen und Programmen. |
|||
Der Datenhaltungsteil kann mit COBOL-Mitteln oder mit einem Datenbankanschluss realisiert werden. Für den Zugriff auf relationale Datenbanken stellt COBOL [[embedded SQL]] (EXEC SQL) zur Verfügung. Auch kann man [[stored procedure|Vorratsprozeduren]] in COBOL programmieren. |
|||
Insgesamt lässt sich sagen, dass mit der Programmiersprache Cobol viel und mit Verstärkung durch Transaktionssysteme und kleinen Hilfsroutinen in C oder Assembler so ziemlich alles geht. |
|||
COBOL ist in der Wirtschaft, insb. bei Banken und Versicherungen<ref>Manager Magazin: [https://www.manager-magazin.de/unternehmen/artikel/us-banken-brauchen-it-kraefte-manager-holen-cobol-veteranen-zurueck-a-1143632.html ''Programmierer mit 70 Jahren oder älter dringend gesucht''], abgerufen am 23. Mai 2020.</ref><ref>IT-Finanz-Magazin; [https://www.it-finanzmagazin.de/cobol-60-sechzig-evergreen-nachwuchssorgen-94478/ ''COBOL wird sechzig – Evergreen mit Nachwuchssorgen''], abgerufen am 23. Mai 2020.</ref>, und der Verwaltung, z. B. bei den Finanzbehörden, weit verbreitet. Aufgrund der historisch gewachsenen Anzahl an COBOL-Programmen ist es für die Unternehmen sehr schwer und sehr teuer, diese zu pflegen und zu ersetzen. Mangelnde Dokumentation ist hier jedoch als Hauptgrund zu nennen ([[Softwarekrise]]), nicht jedoch die Unersetzlichkeit von COBOL. |
|||
==Entwicklung und Standardisierung== |
|||
Ein Ausschuss des oben erwähnten CODASYL erarbeitete im Jahr 1959 einige Grundsätze, legte den Namen COBOL fest, und veröffentlichte im April 1960 seinen Abschlussbericht mit den ersten Spezifikationen der Programmiersprache, die als COBOL-60 in die Geschichte eingingen. |
|||
Einer Umfrage aus dem Jahr 2022 in 49 Ländern zufolge wird der Bestand an produktiv genutztem COBOL-Code auf rund 800 Milliarden Zeilen geschätzt.<ref>[https://www.it-finanzmagazin.de/cobol-soweit-das-auge-reicht-ueber-800-milliarden-zeilen-code-tendenz-steigend-134409/ COBOL, soweit das Auge reicht: über 800 Milliarden Zeilen Code im Einsatz] (vom 4. Februar 2022; abgerufen am 23. Februar 2024) auf [https://www.it-finanzmagazin.de IT Finanzmagazin]</ref> |
|||
Im Rahmen von CODASYL gab es dann ständig einen Ausschuss, teilweise mit Unterausschüssen, der bzw. die sich mit der Weiterentwicklung von COBOL befassten und im Lauf der Jahrzehnte verschiedene Namen und verschiedene Status innerhalb von CODASYL hatten. |
|||
===Entwicklung durch [[CODASYL]]=== |
|||
COBOL-60 zeigte die Praktikabilität der angestrebten gemeinsamen Programmiersprache. |
|||
Einige der Neuerungen in COBOL der letzten Jahrzehnte – in Klammern der Standard, der dies einführte: |
|||
COBOL-61 war nur teilweise kompatibel mit der Vorgängerversion, wurde aber weitgehend in zahlreichen Compilern implementiert. CODASYL hat sich dann darauf verpflichtet, die Sprache von da aus evolutionär zu weiterzuentwickeln, statt revolutionäre Änderungen vorzunehmen. |
|||
* ''Nested Program'' (COBOL 85) erlaubt es, innerhalb eines COBOL-Programms Prozeduren mit lokalen Variablen zu schreiben. |
|||
* ''Intrinsic Functions'' (Anhang von 1989 zu COBOL 85) für mathematische und andere Funktionen. |
|||
* Das COBOL-Verb XML PARSE (proprietär) bietet einen integrierten [[Extensible Markup Language|XML]]-Parser. Ebenso gibt es JSON PARSE für [[JSON]]. |
|||
* OO-Erweiterungen (COBOL 2002) erleichterten die Zusammenarbeit mit objektorientierten Programmiersprachen. |
|||
* Formatfreie Notation (COBOL 2002) erlaubt eine Zeilenlänge von 255 Zeichen und ein Verzicht auf die alten Margins A und B. |
|||
* Bedingte Kompilierung (COBOL 2002) und ein ''preprocessing'' (proprietär). |
|||
== Entwicklung und Standardisierung == |
|||
Mit COBOL-61 EXTENDED kamen u.a. die SORT-Möglichkeiten und der REPORT WRITER hinzu. |
|||
Ein Ausschuss des oben erwähnten [[CODASYL]] erarbeitete im Jahr 1959 einige Grundsätze, legte den Namen COBOL fest und veröffentlichte im April 1960 seinen Abschlussbericht mit den ersten Spezifikationen der Programmiersprache, die als COBOL-60 in die Geschichte eingingen. |
|||
Im Rahmen von CODASYL gab es dann ständig einen Ausschuss, teilweise mit Unterausschüssen, der bzw. die sich mit der Weiterentwicklung von COBOL befassten und im Lauf der Jahrzehnte verschiedene Namen und verschiedene Status innerhalb von CODASYL hatten. |
|||
COBOL, EDITION 1965 fügte u.a. interne Tabellen und Optionen für Dateibearbeitung hinzu. |
|||
=== Entwicklung durch CODASYL === |
|||
Weitere Dokumente zur Entwicklung sind die CODASYL COBOL JOURNAL OF DEVELOPMENT der Jahre 1968, 1969, 1970, 1973, 1976, 1978, 1981 und 1984. |
|||
COBOL-60 zeigte die Praktikabilität der angestrebten gemeinsamen Programmiersprache. |
|||
===Erweiterungen durch [[X/Open]], die [[Open Group]]=== |
|||
Im Rahmen der Bemühungen um einen Standard für das Betriebssystem [[Unix]] durch die Industrievereinigung X/Open wurden dafür auch Spezifikationen für COBOL vereinbart, deren jüngste von 1991 aus den höchsten Stufen der vorgeschriebenen Module von COBOL-85 besteht, mit der Erweiterung von 1989 durch die "Intrinsic Functions", aber ohne Report-Writer, Segmentierung und Debugging, dafür aber mit eigenen Erweiterungen für Interaktion mit Bildschirmformularen (SCREEN SECTION und ACCEPT/DISPLAY), gemeinsamen Zugriff auf Dateien mit Sperren auf Dateien und Sätze, sowie Internationalisierung mit z.B. Doppelbyte-Zeichensätzen. |
|||
COBOL-61 war nur teilweise kompatibel mit der Vorgängerversion, wurde aber weitgehend in zahlreichen Compilern implementiert. [[CODASYL]] hat sich dann darauf verpflichtet, die Sprache von da aus evolutionär weiterzuentwickeln, statt revolutionäre Änderungen vorzunehmen. |
|||
===Standardisierung durch [[ANSI]]=== |
|||
Im Jahr 1960 wurde, angeregt durch den Industrieverband "Computer and Business Equipment Manufacturers Association" im Rahmen der US-amerikanischen Standardisierungsorganisation ([[American_Standards_Association | ASA]]) ein "Committee on Computers and Information Processing" mit der Nummer X3, geschaffen, welches dann einen Unterausschuss X3.4 für Programmiersprachen einrichtete, der wiederum einen Unterausschuß X3.3.4 für COBOL einrichtete. Im Dezember 1962 wurden Hersteller und andere Interessierte zur Mitarbeit an der Standardisierung eingeladen, wobei dann festgelegt wurde, dass die Standardisierung auf den Publikationen des CODASYL fußen sollten. |
|||
Mit COBOL-61 EXTENDED kamen u. a. die SORT-Möglichkeiten und der REPORT WRITER hinzu. |
|||
Der erste Standard wurde am 23. August 1968 als ''USA Standard COBOL 1968'' verabschiedet und als Dokument X3.23-1968 veröffentlicht. |
|||
COBOL, EDITION 1965 fügte u. a. interne Tabellen und Optionen für Dateibearbeitung hinzu. |
|||
Der Ausschuß X3.4.4 wurde dann zum Technischen Komitee X3J4, wie er auch heute noch heißt, und machte sich an die Arbeit, den nächsten Standard zu entwickeln, der dann am 10.5.1974 als ''American National Standard COBOL 1974'' verabschiedet und dann im Dokument ANS X3.23-1974 veröffentlicht wurde. |
|||
Weitere Dokumente zur Entwicklung sind die CODASYL COBOL JOURNAL OF DEVELOPMENT der Jahre 1968, 1969, 1970, 1973, 1976, 1978, 1981 und 1984. |
|||
Der nächste Standard wurde im April 1985 von X3J4 verabschiedet und im September vom zuständigen Entscheidungsgremium der inzwischen ANSI heißenden Organisation angenommen und dann als ANS X3.23-1985 veröffentlicht. COBOL-85 führte mit Begrenzern wie ''END-IF'' und ''END-PERFORM'' erstmals die Möglichkeit ein, in COBOL beliebig geschachtelte Entscheidungs- (IF, EVALUATE) und Wiederholungsanweisungen (PERFORM) zu schreiben und damit die sog. "[[Strukturierte Programmierung]]" in COBOL zu praktizieren. Zu COBOL-85 wurde später ein Zusatz mit eingebauten (intrisic) Funktionen und eine weiterer mit Korrekturen zum Standard veröffentlicht. |
|||
=== Erweiterungen durch X/Open, die Open Group === |
|||
Der aktuelle Standard wurde 2002 verabschiedet. Wesentliche Änderungen darin sind die Übernahme der Erweiterungen durch X/Open, die explizite Unterstützung von internationalen Zeichensätzen einschließlich [[Unicode]], die [[Objektorientierte Programmierung]] sowie bedingte Compilierung, neben zahlreichen anderen Erweiterungen und Präzisierungen. |
|||
Im Rahmen der Bemühungen um einen Standard für das Betriebssystem [[Unix]] durch die Industrievereinigung [[X/Open]], die [[Open Group]], wurden dafür auch Spezifikationen für COBOL vereinbart, deren jüngste von 1991 aus den höchsten Stufen der vorgeschriebenen Module von COBOL-85 besteht, mit der Erweiterung von 1989 durch die „Intrinsic Functions“, aber ohne Report-Writer, Segmentierung und Debugging, dafür aber mit eigenen Erweiterungen für Interaktion mit Bildschirmformularen (SCREEN SECTION und ACCEPT/DISPLAY), gemeinsamen Zugriff auf Dateien mit Sperren auf Dateien und Sätze, sowie Internationalisierung mit z. B. Doppelbyte-Zeichensätzen. |
|||
=== Standardisierung durch ANSI === |
|||
Nach dem Ende von [[CODASYL]] hat das Komitee J4 auch die Verantwortung nicht nur für die Standardisierung, sondern auch für die Entwicklung übernommen. |
|||
Im Jahr 1960 wurde, angeregt durch den Industrieverband „Computer and Business Equipment Manufacturers Association“, im Rahmen der US-amerikanischen Standardisierungsorganisation ([[American National Standards Institute|ASA]]) ein „Committee on Computers and Information Processing“ mit der Nummer X3 geschaffen, welches dann einen Unterausschuss X3.4 für Programmiersprachen einrichtete, der wiederum einen Unterausschuss X3.4.4 für COBOL einrichtete. Im Dezember 1962 wurden Hersteller und andere Interessierte zur Mitarbeit an der Standardisierung eingeladen, wobei dann festgelegt wurde, dass die Standardisierung auf den Publikationen des CODASYL fußen sollten. |
|||
Der erste Standard wurde am 23. August 1968 als ''USA Standard COBOL 1968'' verabschiedet und als Dokument X3.23-1968 veröffentlicht. |
|||
Der nächste Standard wird für das Jahr 2008 vorbereitet. |
|||
Der Ausschuss X3.4.4 wurde dann zum Technischen Komitee X3J4, wie er auch heute noch heißt, und machte sich an die Arbeit, den nächsten Standard zu entwickeln, der dann am 10. Mai 1974 als ''American National Standard COBOL 1974'' verabschiedet und dann im Dokument ANS X3.23-1974 veröffentlicht wurde. |
|||
===Internationale Standardisierung bei [[ISO]]=== |
|||
Das Komitee X3J4 (führe X3.4.4) hat von Anfang an eng mit verschiedenen internationalen Gremien zusammengearbeitet. Dementsprechend stimmte ANS COBOL X3.23-1968 mit der ISO-Empfehlung für COBOL überein. |
|||
Der nächste Standard wurde im April 1985 von X3J4 verabschiedet und im September vom zuständigen Entscheidungsgremium der inzwischen [[ANSI]] heißenden Organisation angenommen und dann als ANS X3.23-1985 veröffentlicht. COBOL-85 führte mit Begrenzern wie ''END-IF'' und ''END-PERFORM'' erstmals die Möglichkeit ein, in COBOL beliebig geschachtelte Entscheidungs- (IF, EVALUATE) und Wiederholungsanweisungen (PERFORM) zu schreiben und damit die sogenannte [[strukturierte Programmierung]] in COBOL zu praktizieren. Zu COBOL-85 wurde später ein Zusatz mit eingebauten (intrinsic) Funktionen und ein weiterer mit Korrekturen zum Standard veröffentlicht. |
|||
In der ISO ist das ''Technical Committee ISO/TC 97, Computers and Information Processing'# zuständig, dessen Sekretariat vom ANSI gestellt wird. |
|||
Ein neuer Standard wurde 2002 verabschiedet. Wesentliche Änderungen darin sind die Übernahme der Erweiterungen durch X/Open, die explizite Unterstützung von internationalen Zeichensätzen einschließlich [[Unicode]], die [[objektorientierte Programmierung]] sowie bedingte Kompilierung, neben zahlreichen anderen Erweiterungen und Präzisierungen. |
|||
ISO hat zu COBOL eine Empfehlung (Recommendation) R-1989:1972, sowie Standards ISO 1989:1978 und ISO 1989:1985 verabschiedet, und dabei die Vorgabe des US-Standardisierungsgremiums übernommen. |
|||
Nach dem Ende von [[CODASYL]] hat das Komitee J4 auch die Verantwortung nicht nur für die Standardisierung, sondern auch für die Entwicklung übernommen. |
|||
Der aktuelle Standard 2002 ist umgekehrt zuerst als ISO/IEC 1989:2002 veröffentlicht und dann von den nationalen Standardorganisationen übernommen worden. |
|||
Der nächste Standard wurde für das Jahr 2010 vorbereitet und wurde 2014 veröffentlicht. |
|||
===Module und standardkonforme Implementierungen=== |
|||
COBOL-68, COBOL-74 und COBOL-85 ordneten die verschiedenen Features der Sprache einem Modul mit jeweils einem bis drei "Levels" zu, woraus dann minimale und volle Implementierungen des Standards als Kombination von bestimmten Levels der jeweiligen Module definiert wurden. Eine mit COBOL-2002 konforme Implementierung muss den gesamten Sprachumfang implementieren. |
|||
=== Internationale Standardisierung bei ISO === |
|||
===Cobol Compiler=== |
|||
Das Komitee X3J4 (früher X3.4.4) hat von Anfang an eng mit verschiedenen internationalen Gremien zusammengearbeitet. Dementsprechend stimmte ANS COBOL X3.23-1968 mit der [[International Organization for Standardization|ISO]]-Empfehlung für COBOL überein. |
|||
Für Computer der Klassen "Großrechner" und "Mittlere Datentechnik" boten und bieten deren jeweiligen Hersteller -- IBM, Unisys, Siemens, HP, u.a. -- auf ihre proprietären Betriebssysteme zugeschnittene COBOL-Compiler an, z.T. verschiedene Compiler, die beispielsweise verschiedenen Standards entsprechen. |
|||
In der ISO ist das ''Technical Committee ISO/TC 97, Computers and Information Processing'' zuständig, dessen Sekretariat vom ANSI gestellt wird. |
|||
Für Betriebssysteme, die aus der UNIX bzw. MS-DOS-Tradition entstanden sind, gibt es COBOL-Compiler von verschiedenen Software-Herstellern. Näheres siehe in der unten verlinkten COBOL-FAQ von William M. Klein. |
|||
ISO hat zu COBOL eine Empfehlung (Recommendation) R-1989:1972 sowie Standards ISO 1989:1978 und ISO 1989:1985 verabschiedet und dabei die Vorgabe des US-Standardisierungsgremiums übernommen. |
|||
==Weblinks== |
|||
* Deutschsprachiges COBOL-Tutorial: http://www.cobol-workshop.de |
|||
* Website des COBOL-Standards: http://www.cobolstandards.com/ |
|||
* COBOL-FAQ von Bill Klein: http://objectz.com/faqs/cobolfaq.htm |
|||
* [http://www.opengroup.org/bookstore/catalog/x98lc.htm X/Open COBOL Spezifikationen ] |
|||
* Diverse Websites zu COBOL: |
|||
** http://www.acucorp.com/ |
|||
** http://www.cobolportal.com/ |
|||
** http://www.cobolreport.com |
|||
** http://www.infogoal.com/cbd/cbdhome.htm |
|||
** http://www.csis.ul.ie/cobol/default.htm |
|||
* Webring "All Things COBOL": http://www.geocities.com/Eureka/2006/ring.htm |
|||
* Eine lustige Geschichte: http://www.windswept.org.uk/funnies/COBOLStory.htm |
|||
2002 wurde ein weiterer Standard umgekehrt zuerst als ISO/IEC 1989:2002 veröffentlicht und dann von den nationalen Standardorganisationen übernommen. Dieser wurde 2014 als ISO/IEC 1989:2014 erweitert. |
|||
[[Kategorie:Programmiersprache]] |
|||
Der aktuelle Standard wurde im Januar 2023 als ISO/IEC 1989:2023 veröffentlicht. |
|||
[[cs:COBOL]] |
|||
[[da:COBOL]] |
|||
=== Module und standardkonforme Implementierungen === |
|||
[[en:COBOL]] |
|||
COBOL-68, COBOL-74 und COBOL-85 ordneten die verschiedenen Features der Sprache einem Modul mit jeweils einem bis drei „Levels“ zu, woraus dann minimale und volle Implementierungen des Standards als Kombination von bestimmten Levels der jeweiligen Module definiert wurden. Eine mit COBOL-2002 konforme Implementierung muss den gesamten Sprachumfang implementieren. |
|||
[[es:COBOL]] |
|||
[[fr:Cobol]] |
|||
=== COBOL-Compiler === |
|||
Für Computer der Klassen „[[Großrechner]]“ und „[[Mittlere Datentechnik]]“ boten und bieten deren jeweilige Hersteller – IBM, Unisys, Siemens, Fujitsu-Siemens, HP, Bull u. a. – auf ihre proprietären Betriebssysteme zugeschnittene COBOL-Compiler an, z. T. verschiedene Compiler, die beispielsweise verschiedenen Standards entsprechen. |
|||
[[ia:COBOL]] |
|||
[[it:COBOL]] |
|||
Für Betriebssysteme, die aus der UNIX- bzw. MS-DOS-Tradition entstanden sind, gibt es COBOL-Compiler von verschiedenen Software-Herstellern. |
|||
[[ja:COBOL]] |
|||
Mit GnuCOBOL existiert eine quelloffene Implementierung der Programmiersprache.<ref>{{Internetquelle |url=https://sourceforge.net/projects/open-cobol/ |titel=GnuCOBOL (formerly OpenCOBOL) |abruf=2016-12-27}}</ref> |
|||
[[ko:COBOL]] |
|||
[[lt:Cobol]] |
|||
=== COBOL-Generatoren === |
|||
[[nl:COBOL]] |
|||
Es gibt [[Codegenerator]]en, die COBOL-Programme bzw. Teile davon generieren und so die Entwicklungsarbeit erleichtern. Dazu gehören zum Beispiel SWT01 und SWT/VDA des Herstellers FSP, CA Gen (ehemals Cool:Gen) von [[CA Technologies]], sowie die Generatorsysteme ADSplus und SCORE von Delta Software Technology. |
|||
[[pl:COBOL]] |
|||
[[sv:COBOL]] |
|||
== Literatur == |
|||
[[uk:Кобол]] |
|||
* Franck Barbier, Jean-Luc Recoussine: ''COBOL Software Modernization'', iSTE Wiley, 1. Auflage 2015, ISBN 1-84821-760-9 |
|||
* Michael Coughlan: ''Beginning COBOL for Programmers'', Apress, 1. Auflage 2014, ISBN 1-4302-6253-2 |
|||
* Nancy B. Stern, Robert A. Stern u. James P. Ley: ''COBOL for the 21st Century'',<br />John Wiley & Sons, 11. Auflage 2013, ISBN 1-118-73953-1 |
|||
== Weblinks == |
|||
{{Wiktionary|COBOL}} |
|||
{{Commonscat|COBOL|audio=0|video=0}} |
|||
* [https://riemke-it.de/beispiele-cobol.htm COBOL-Beispiele] aus der Praxis von heute |
|||
* [https://www.ibm.com/support/knowledgecenter/en/ssw_ibm_i_71/rzahg/rzahgcobol.htm Handbücher zu ILE COBOL] |
|||
* [https://www.iso.org/standard/74527.html ISO/IEC 1989:2023] |
|||
== Einzelnachweise == |
|||
<references /> |
|||
{{Normdaten|TYP=s|GND=4010323-7|LCCN=sh85027548}} |
|||
[[Kategorie:Imperative Programmiersprache]] |
|||
[[Kategorie:Programmiersprache mit einem ISO-Standard]] |
|||
[[Kategorie:Programmiersprache]] |
|||
[[Kategorie:Wirtschaftsinformatik]] |
|||
[[Kategorie:Abkürzung]] |
Aktuelle Version vom 28. Februar 2025, 10:44 Uhr
COBOL | |
---|---|
Basisdaten | |
Paradigmen: | Zunächst rein imperativ, später erweitert um Elemente der strukturierten, prozeduralen und heutzutage sogar objektorientierten Programmierung |
Erscheinungsjahr: | 1959 |
Entwickler: | Grace Hopper, William Selden, Gertrude Tierney, Howard Bromberg, Howard Discount, Vernon Reeves, Jean E. Sammet |
Aktuelle Version | ISO/IEC 1989:2023[1] (2023) |
Typisierung: | stark, statisch |
Dialekte: | DEC COBOL, HP COBOL, IBM OS/VS COBOL, IBM COBOL/II, IBM COBOL SAA, IBM Enterprise COBOL, IBM COBOL/400, IBM ILE COBOL, Unix COBOL X/Open, Micro Focus COBOL, Microsoft COBOL, Ryan McFarland RM/COBOL, Ryan McFarland RM/COBOL-85, DOSVS COBOL, UNIVAC COBOL, Realia COBOL, Fujitsu COBOL, ACUCOBOL-GT |
Beeinflusst von: | FLOW-MATIC, COMTRAN, FACT |
Beeinflusste: | PL/I, PL/SQL, ABAP |
Betriebssystem: | z/OS, Windows, Linux, Mac OS X, BS2000, OS/400 u. v. m. |
COBOL ist eine Programmiersprache, die in der Frühzeit der Computerentwicklung, Ende der 1950er-Jahre, entstand und bis heute verwendet wird.[2] Der Stil dieser Programmiersprache ist stark an die natürliche Sprache angelehnt und dient vor allem der Programmierung kaufmännischer Anwendungen.
Die Abkürzung COBOL steht für „Common Business Oriented Language“.[3]
Geschichte
[Bearbeiten | Quelltext bearbeiten]COBOL entstand aus dem dringenden Wunsch, eine hardwareunabhängige, standardisierte, problemorientierte Sprache für die Erstellung von Programmen für den betriebswirtschaftlichen Bereich anwenden zu können. Die Programmierung kaufmännischer Anwendungen unterscheidet sich von technisch-wissenschaftlichen Anwendungen vor allem durch die Handhabung großer Datenmengen statt der Ausführung umfangreicher Berechnungen. Nachdem die Programmierung technisch-wissenschaftlicher Anwendungen durch FORTRAN bereits sehr vereinfacht worden war, sollte die neue Programmiersprache kaufmännische Problemstellungen, insbesondere die Handhabung großer Datenmengen und deren Ein- und Ausgabe stärker unterstützen – wozu bis dahin weitgehend Assemblersprachen verwendet wurden.
Eine vom amerikanischen Verteidigungsministerium eingesetzte Arbeitsgruppe entwickelte einen Standard aus der Verbindung der damaligen Programmiersprachen FLOW-MATIC von Sperry Univac (Remington-Rand), Commercial Translator (COMTRAN) von IBM und FACT von Minneapolis-Honeywell. Namentlich beteiligt hieran war Grace M. Hopper, die bereits FLOW-MATIC sowie den ersten Compiler (A-0) entwickelt hatte.[4][5]
Das Ergebnis wurde 1960 als COBOL-60 von CODASYL verabschiedet, in der Folgezeit weiterentwickelt und von nationalen und internationalen Normierungsinstituten (ANSI, ISO) standardisiert.
COBOL fand schnell den Weg in die zivile Nutzung als eine der ersten kommerziell eingesetzten kompilierbaren Programmiersprachen und ist bis heute eine der am weitesten verbreiteten für kaufmännische Anwendungen.
2020 entstand in den USA noch einmal Nachfrage nach COBOL-Entwicklern, als im Zuge der Corona-Pandemie die Arbeitslosenzahlen sprunghaft anstiegen, aber die Verwaltungssysteme der Arbeitslosenversicherung im US-Bundesstaat New Jersey der Nachfrage nicht mehr gewachsen waren.[3][6]
Sprachsyntax
[Bearbeiten | Quelltext bearbeiten]Ursprünglich wurde COBOL nur in Großbuchstaben geschrieben, da nur Lochkarten und Zeilendrucker ohne Kleinbuchstaben zur Verfügung standen. Auch heute wird nicht zwischen Groß- und Kleinschreibung unterschieden. COBOL ist somit case insensitive.
Ein COBOL-Programm ist in Teile (DIVISION
), Kapitel (SECTION
) und Abschnitte (PARAGRAPH
) gegliedert.
Die vier DIVISION
s sind in ihrer festgelegten Reihenfolge:
Identification Division
mit dem Programmnamen und einigen weitgehend obsoleten Paragraphen für Kommentare;Environment Division
, in der Schnittstellen zum Betriebs- und dessen Dateisystem definiert werden;Data Division
mit der Definition der Programmvariablen und Datenstrukturen undProcedure Division
mit den prozeduralen Anweisungen.
In der IDENTIFICATION DIVISION
gibt es keine SECTION
s, und in der PROCEDURE DIVISION
können neuerdings SECTION
s und auch PARAGRAPH
s entfallen. ENVIRONMENT
und DATA DIVISION
s können unter Umständen ganz entfallen.
Hieran sieht man die strikte Trennung von Datendeklaration und prozeduralen Anweisungen, durch die sich COBOL auszeichnet. Im Prozedurteil kann man nur Variablen benutzen, die vorher im Datenteil deklariert worden sind. Auch das Aussehen von formatierten Ausgaben wird nicht im Prozedurteil, sondern im Datenteil durch die PICTURE
-Klausel festgelegt. Der REPORT WRITER
macht es möglich, die Struktur einer Druckliste komplett im Datenteil als physische Struktur von Seiten und logische Struktur von Postenzeilen mit Gruppensummen etc. zu beschreiben, ohne dass sich der Prozedurteil darum kümmern muss.
Kodierung
[Bearbeiten | Quelltext bearbeiten]Das traditionelle Kodierschema bei COBOL entspricht der Lochkarte mit ihren 80 Spalten, d. h. Schreibstellen. Dabei waren die ersten 6 Stellen für die Zeilennummerierungen reserviert. Spalte 7 wurde zur Kennzeichnung einer Kommentar- oder einer Fortsetzungszeile beziehungsweise einer, die nur für das Debugging übersetzt werden soll, reserviert. Spalte 8 bis 11 (Area A) beinhaltete die Namen von Divisions, Sections und Paragraphs. Die 12. bis 72. Spalte (Area B) beherbergten alles übrige, zum Beispiel Anweisungen (statements). Spalte 73 bis 80 waren für sonstige Markierungen wie z. B. den Namen des Programms oder Quelltext-Elementen vorgesehen.
Die Standards ab 2002 kennen neben dem fixen Zeilenformat, das die Einteilung in Area A und Area B aufhebt, ein ganz freies Format, das in den Spalten 1 bis 255 alles erlaubt. Die Sonderrolle der Spalte 7 entfällt, da Kommentare mit *>
eingeleitet, Literale mittels &
zusammengesetzt und Debuggingzeilen mittels bedingter Übersetzung realisiert werden >>DEFINE … >>IF …
.
Ein fast minimales COBOL-Programm:
Identification Division.
Program-ID. HALLOPGM.
Procedure Division.
Display "Hallo Welt!".
STOP RUN.
Datendeklarationen
[Bearbeiten | Quelltext bearbeiten]… erfolgen in der Data Division
- Dateien und deren Satzstrukturen werden in der File Section beschrieben.
- Statische (globale) Variablen werden in der Working-Storage Section definiert.
- Automatische (lokale bzw. dynamische) Variablen werden in der Local-Storage Section definiert (siehe Stack).
- Aufruf-Parameter werden in der
Linkage Section
definiert. - Komplexe Drucklisten werden in der
Report Section
definiert. - Bildschirmein- und -ausgabe in der
Screen Section
.
Zur Deklaration von Variablen bietet COBOL zahlreiche Klauseln, deren wichtigsten die Stufennummer, die PICTURE-Klausel und die USAGE-Klausel sind.
- Stufennummer
Die Stufennummer 77 kennzeichnet eine freistehende Variable. Die Stufennummer 01 kann ebenfalls eine freistehende Variable bezeichnen, leitet aber normalerweise die Deklaration einer Gruppe ein – was in anderen Sprachen als Record (Pascal u. ä.) oder struct (C++, C u. ä.) bezeichnet wird. Die Stufennummern 02 bis 49 kennzeichnen dann dieser Gruppe untergeordnete Datendeklarationen, die selber auch wieder Gruppen sein können. Eine Datendeklaration, die keine untergeordneten Datendeklarationen (d. h. mit höheren Stufennummern) hat, wird in COBOL als elementar (elementary item) bezeichnet, anderenfalls ist es eine Gruppen-Variable (group item). Derartige Datendeklarationen kann man abstrakt als Baum darstellen; mit den Gruppen als Knoten und den elementary items als Blättern – denen über die PIC-Klausel Datenformate zugeordnet sind.
Mit der speziellen Stufennummer 66 kann man ganzen Speicherbereichen einen anderen Namen geben, mit 88 einen Bedingungsnamen definieren, der wie ein boolescher Ausdruck in zum Beispiel einer IF-Anweisung verwandt werden kann.
Die Stufennummern werden üblicherweise zweistellig geschrieben. Aus den Lochkartenzeiten stammt die Gewohnheit, die Stufennummern in einer Gruppendefinition nicht fortlaufend, sondern in Schritten von 5 oder 10 zu vergeben, weil man dann Zwischenstufen einfügen konnte, ohne gleich einen ganzen Kartenstapel neu lochen zu müssen.
Das folgende Beispiel beschreibt das Layout der traditionellen 80-stelligen COBOL-Programmzeile:
01 Cobol-Zeile USAGE DISPLAY.
05 Zeilennummer PIC 9(6).
05 Indikator PIC X.
88 Ist-Kommentar VALUES '*' '/'.
88 Ist-Fortsetzungszeile VALUE '-'.
88 Ist-Debuggingzeile VALUE 'D' 'd'.
05 Bereich-A-und-B.
10 Bereich-A PIC X(4).
10 Bereich-B PIC X(61).
05 Zeilen-Endekennung PIC X(8).
Die Definition eines Wertebereiches sieht als Beispiel so aus:
01 Wertebereich PIC 99V99 USAGE COMPUTATIONAL.
88 Einerwerte Value 1 thru 9.
88 Zehnerwerte Value 10 thru 19.
88 Zwanzigerwerte Value 20 thru 29.
- Internes und Externes Datenformat
Äußere Erscheinung und interne Repräsentation werden im Wesentlichen durch die Klauseln PICTURE
und USAGE
bestimmt. Mit USAGE COMP
werden binäre Rechen- und Vergleichsoperationen ausgeführt, USAGE DISPLAY
dient zur Anzeige. Arithmetische Operationen und Vergleiche (kleiner/gleich/größer …) sind mit USAGE COMP-3
direkt möglich.
Mit Angaben hinter PICTURE
wird die Anzahl der Stellen/Zeichen oder auch Editiersymbole wie Dezimal- oder Tausendertrennzeichen, Vorzeichen, Währungssymbole, gedachtes Dezimaltrennzeichen (V) etc. festgelegt. Sie bestimmen eine elementare Variable damit als entweder alphabetisch, alphanumerisch, numerisch oder numerisch-editiert. Sind für arithmetische Operationen (wie ADD BETRAG-X to SUMME-Y
oder IF DATUM-A > DATUM-B)
Variablen mit uneinheitlichen numerischen Formaten beteiligt, so wird vor der Operation automatisch eines oder beide der Datenfelder in ein (für die Operation) gültiges Format konvertiert.
Die Formatierung für sichtbare Ausgaben wird durch die Datendeklaration bestimmt, nicht durch prozedurale Anweisungen wie in Sprachen wie Pascal oder C. Weitere der insgesamt etwa 60 möglichen Klauseln einer Datendeklaration möge man in einem COBOL-Handbuch nachschlagen.
- Tabellenformate
Mehrfach auftretende Daten (in COBOL ‚Tabellen‘ genannt, siehe Feld (Datentyp)) werden durch die OCCURS
-Klausel definiert; Beispiel für eine mehrdimensionale Tabelle:
05 PRODUKT OCCURS 100. 10 PRODUKTNR PICTURE 999. 10 PRODUKTNAME PICTURE X(30). 10 PREIS PICTURE 999V99 OCCURS 5 INDEXED BY IND_KUNDENGRUPPE.
Die Occurs-Klausel ist sowohl je Datengruppe als auch für Elementarfelder möglich. Die Adressierung der jeweiligen Dimension kann alternativ durch die Index-Methode (Zusatz Indexed BY <IND-NAME>
) oder durch ein Subscript erfolgen:
- Ein ‚Subscript‘ ist der Name einer (numerischen) Variable im jeweiligen COBOL-Befehl (Beispiel:
MOVE PRODUKTNR (PNR) TO xx
). - Ein ‚Index‘ enthält die Distanz der zu adressierenden Datendimension zum Beginn der Tabelle und wird mit einem SET-Befehl explizit auf diesen Wert eingestellt:
SET IND_KUNDENGRUPPE BY KUNDENGRP
. Die Indizierung ist vorteilhaft, wenn sich mehrere/viele Einzelbefehle auf die zu adressierende Dimension beziehen, weil der wesentliche Teil der Adressberechnung nicht je Befehlsausführung, sondern bei SET erfolgt.
Die Maschinenbefehle zur Berechnung des Abstands der durch Index/Subscript adressierten Dimension zum Anfang der Tabelle {z. B. (PNR-1)*Länge(Datengruppe PRODUKT)} werden in beiden Versionen automatisch dem eigentlichen COBOL-Befehl (MOVE, IF usw.) vorangestellt und ausgeführt. In mehrdimensionalen Tabellen (siehe Beispiel) können beide Adressierungsmethoden gemischt angewendet werden.
Mit dem Zusatz DEPENDING ON xxx
kann die Anzahl der Tabellenelemente variabel definiert werden.
Prozedurale Anweisungen
[Bearbeiten | Quelltext bearbeiten]In der Procedure Division
findet sich der ausführbare Programmcode. Die Ausführung beginnt mit der ersten Anweisung hinter der Überschrift Procedure Division
bzw. den DECLARATIVES
, deren Ausführung nur durch bestimmte Ereignisse ausgelöst wird. Danach werden alle Anweisungen sequentiell ausgeführt, bis ein STOP RUN
das Programm beendet, oder ein GO TO
bzw. PERFORM
(mit anschließender Rückkehr) zu einer anderen Stelle im Programm verzweigt.
Die Procedure Division besteht aus einer oder mehreren Prozeduren. Eine Prozedur ist entweder
- eine Section: Bezeichnet mit einem Namen, der in Spalte 8 beginnt, gefolgt von dem Schlüsselwort
SECTION
und einem Punkt; enthält meist mehrere Paragraphen. - ein Paragraph: Bezeichnet mit einem Namen, der in Spalte 8 beginnt und mit Punkt endet.
Eine solche Prozedur enthält die Anweisungen des COBOL-Programms (Statements).
Prozeduren können mit der COBOL-Anweisung Perform
von anderen Stellen im Programm aus ausgeführt/aufgerufen werden. Durch den Zusatz THRU <proz-name>
in der Perform-Anweisung können mehrere Prozeduren zur Ausführung zusammengefasst werden. Es gibt keine formale Parameterübergabe, alle Prozeduren haben Zugriff auf alle Felder in der Data Division.
Mittels CALL
können externe Programme (COBOL oder andere Programmiersprachen) aufgerufen werden. Dabei werden Parameter By Reference oder By Content (je nach COBOL-Version auch By Value genannt) übergeben, wodurch u. a. unterschieden wird, ob übergebene Parameter-Variablen vom aufgerufenen Programm für das aufrufende Programm wirksam geändert werden können (by ref) oder nicht (by content).
COBOL unterstützt seit dem Standard 1974 (VS COBOL II) die strukturierte Programmierung; seither ist die Verwendung von ‚GOTO‘ zwar noch möglich, aber verpönt. In der professionellen Programmierung herrschen hausinterne Programmierstandards, welche in der Mehrzahl festlegen, dass Prozeduren ausschließlich aus einer Section bestehen.
COBOL wurde mit einer an der englischen Sprache angelehnten Syntax entworfen, um ‚selbst-dokumentierend‘ und auch für Nicht-Programmierer im Wesentlichen leicht lesbar zu sein. Alle Anweisungen beginnen mit einem in den ‚COBOL-Schlüsselwörtern‘ reservierten Verb (wie in MOVE x TO y
) – im Gegensatz zu Kurznotierungen (wie y = x
) in anderen modernen Programmiersprachen.
Einfache Codeschnipsel
[Bearbeiten | Quelltext bearbeiten]Zur Darstellung der Syntax wird einfache C-Syntax zu Hilfe genommen.
- Eine Zuweisung
a = b
in C
- entspricht in COBOL
MOVE b TO a
- Arithmetische Ausdrücke und Zuweisungen:
a = b + c
- kann in COBOL folgendermaßen geschrieben werden:
ADD b TO c GIVING a
- oder alternativ
COMPUTE a = b + c
- analog
b = a - 1
in C
- entspricht in COBOL
SUBTRACT 1 FROM a GIVING b
- Der Inkrementoperator
++a
in C
- entspricht in COBOL
ADD 1 TO a
- Der Dekrementoperator
--a
in C
- entspricht in COBOL
SUBTRACT 1 FROM a
IF/ELSE und EVALUATE
[Bearbeiten | Quelltext bearbeiten]IF und ELSE funktionieren so, wie man es erwartet. Das End-If wurde erst mit dem COBOL85-Standard eingeführt. Im COBOL74-Standard wurde die IF-Anweisung noch durch einen Punkt beendet, was eine leicht zu übersehende Fehlerquelle darstellen konnte.
COBOL85-Syntax:
If Nenner > 0
Compute Zahl = Zaehler / Nenner
End-Compute
Else
Display "Nenner sollte > 0 sein!"
Move 0 To Zahl
End-If
COBOL68-Syntax:
If Nenner > 0
Compute Zahl = Zaehler / Nenner
Else
Display "Nenner sollte > 0 sein!"
Move 0 To Zahl.
EVALUATE macht die mehrfache Fallunterscheidung, womit jede Form von CASE oder Switch (wie in C), Folgen von IF/ELSIF/ELSIF/END-IF bis hin zu vollständigen Entscheidungstabellen dargestellt werden kann. Die Anweisung EVALUATE wurde erstmals in COBOL85 integriert, COBOL-Versionen vor der 85-Version kennen kein EVALUATE, so dass dort mehrfache Fallunterscheidungen über – teils schwierig zu lesende – IF-Konstrukte abgebildet werden mussten.
Evaluate True
When Nenner > 0
Compute Zahl = Zaehler / Nenner
When Nenner < 0
Compute Zahl = Zaehler / Nenner * -1
When Other
Display "Nenner sollte nicht 0 sein!"
Move 0 To Zaehler
End-Evaluate
Eine COBOL-Spezialität sind die sogenannten Conditional Statements, das sind COBOL-Anweisungen mit einer Bedingungs-Klausel:
COBOL85-Syntax:
Read Eingabesatz
At End
Display "Dateiende erreicht" Eingabe-Zaehler "gelesen!"
Set Ende-der-Verarbeitung To True
Not At End
Add 1 to Eingabe-Zaehler
End-read
Schleifen
[Bearbeiten | Quelltext bearbeiten]Eine C-Schleife wie „for (i=0; i<10; ++i) {...}
“ wird in COBOL mit PERFORM kodiert (COBOL85-Syntax):
Perform Varying i From 0 By 1
Until i >= 10
...
End-Perform
COBOL heute
[Bearbeiten | Quelltext bearbeiten]Das Haupteinsatzgebiet der Programmiersprache COBOL ist die betriebswirtschaftliche Datenverarbeitung. Wenn EDV-Programme in eine Benutzerschnittstelle, einen Verarbeitungsteil und einen Datenhaltungsteil strukturiert werden, liegt der Einsatzschwerpunkt von COBOL-Programmen im Verarbeitungsteil. In modernerer Terminologie entspricht COBOL dem Backend.
Insbesondere auf PCs, aber auch auf anderen Systemen können als Benutzerschnittstelle eine Vielzahl von Möglichkeiten zum Einsatz kommen. Neben den Standard-COBOL-Anweisungen ACCEPT
zur Tastatureingabe und DISPLAY
zur Bildschirmausgabe kommt aus der X/OPEN-Spezifikation die SCREEN SECTION
hinzu, außerdem herstellerspezifische Lösungen. Hiermit lassen sich als Benutzerschnittstelle Terminals programmieren.
Sofern die Anwendungsarchitektur in mehrere Schichten getrennt ist, kann die Präsentationsschicht auch auf den Client verlagert werden. Dies erlaubt den Zugriff auf COBOL-Anwendungen über grafische Frontends. Client und Server müssen dazu ein Kommunikationsprotokoll unterstützen. Musste ein solches ursprünglich manuell entwickelt werden, so stellten später die Architekturmuster der SOA entsprechende Standards bereit.
Der Datenhaltungsteil kann mit COBOL-Mitteln oder mit einem Datenbankanschluss realisiert werden. Für den Zugriff auf relationale Datenbanken stellt COBOL embedded SQL (EXEC SQL) zur Verfügung. Auch kann man Vorratsprozeduren in COBOL programmieren.
COBOL ist in der Wirtschaft, insb. bei Banken und Versicherungen[7][8], und der Verwaltung, z. B. bei den Finanzbehörden, weit verbreitet. Aufgrund der historisch gewachsenen Anzahl an COBOL-Programmen ist es für die Unternehmen sehr schwer und sehr teuer, diese zu pflegen und zu ersetzen. Mangelnde Dokumentation ist hier jedoch als Hauptgrund zu nennen (Softwarekrise), nicht jedoch die Unersetzlichkeit von COBOL.
Einer Umfrage aus dem Jahr 2022 in 49 Ländern zufolge wird der Bestand an produktiv genutztem COBOL-Code auf rund 800 Milliarden Zeilen geschätzt.[9]
Einige der Neuerungen in COBOL der letzten Jahrzehnte – in Klammern der Standard, der dies einführte:
- Nested Program (COBOL 85) erlaubt es, innerhalb eines COBOL-Programms Prozeduren mit lokalen Variablen zu schreiben.
- Intrinsic Functions (Anhang von 1989 zu COBOL 85) für mathematische und andere Funktionen.
- Das COBOL-Verb XML PARSE (proprietär) bietet einen integrierten XML-Parser. Ebenso gibt es JSON PARSE für JSON.
- OO-Erweiterungen (COBOL 2002) erleichterten die Zusammenarbeit mit objektorientierten Programmiersprachen.
- Formatfreie Notation (COBOL 2002) erlaubt eine Zeilenlänge von 255 Zeichen und ein Verzicht auf die alten Margins A und B.
- Bedingte Kompilierung (COBOL 2002) und ein preprocessing (proprietär).
Entwicklung und Standardisierung
[Bearbeiten | Quelltext bearbeiten]Ein Ausschuss des oben erwähnten CODASYL erarbeitete im Jahr 1959 einige Grundsätze, legte den Namen COBOL fest und veröffentlichte im April 1960 seinen Abschlussbericht mit den ersten Spezifikationen der Programmiersprache, die als COBOL-60 in die Geschichte eingingen.
Im Rahmen von CODASYL gab es dann ständig einen Ausschuss, teilweise mit Unterausschüssen, der bzw. die sich mit der Weiterentwicklung von COBOL befassten und im Lauf der Jahrzehnte verschiedene Namen und verschiedene Status innerhalb von CODASYL hatten.
Entwicklung durch CODASYL
[Bearbeiten | Quelltext bearbeiten]COBOL-60 zeigte die Praktikabilität der angestrebten gemeinsamen Programmiersprache.
COBOL-61 war nur teilweise kompatibel mit der Vorgängerversion, wurde aber weitgehend in zahlreichen Compilern implementiert. CODASYL hat sich dann darauf verpflichtet, die Sprache von da aus evolutionär weiterzuentwickeln, statt revolutionäre Änderungen vorzunehmen.
Mit COBOL-61 EXTENDED kamen u. a. die SORT-Möglichkeiten und der REPORT WRITER hinzu.
COBOL, EDITION 1965 fügte u. a. interne Tabellen und Optionen für Dateibearbeitung hinzu.
Weitere Dokumente zur Entwicklung sind die CODASYL COBOL JOURNAL OF DEVELOPMENT der Jahre 1968, 1969, 1970, 1973, 1976, 1978, 1981 und 1984.
Erweiterungen durch X/Open, die Open Group
[Bearbeiten | Quelltext bearbeiten]Im Rahmen der Bemühungen um einen Standard für das Betriebssystem Unix durch die Industrievereinigung X/Open, die Open Group, wurden dafür auch Spezifikationen für COBOL vereinbart, deren jüngste von 1991 aus den höchsten Stufen der vorgeschriebenen Module von COBOL-85 besteht, mit der Erweiterung von 1989 durch die „Intrinsic Functions“, aber ohne Report-Writer, Segmentierung und Debugging, dafür aber mit eigenen Erweiterungen für Interaktion mit Bildschirmformularen (SCREEN SECTION und ACCEPT/DISPLAY), gemeinsamen Zugriff auf Dateien mit Sperren auf Dateien und Sätze, sowie Internationalisierung mit z. B. Doppelbyte-Zeichensätzen.
Standardisierung durch ANSI
[Bearbeiten | Quelltext bearbeiten]Im Jahr 1960 wurde, angeregt durch den Industrieverband „Computer and Business Equipment Manufacturers Association“, im Rahmen der US-amerikanischen Standardisierungsorganisation (ASA) ein „Committee on Computers and Information Processing“ mit der Nummer X3 geschaffen, welches dann einen Unterausschuss X3.4 für Programmiersprachen einrichtete, der wiederum einen Unterausschuss X3.4.4 für COBOL einrichtete. Im Dezember 1962 wurden Hersteller und andere Interessierte zur Mitarbeit an der Standardisierung eingeladen, wobei dann festgelegt wurde, dass die Standardisierung auf den Publikationen des CODASYL fußen sollten.
Der erste Standard wurde am 23. August 1968 als USA Standard COBOL 1968 verabschiedet und als Dokument X3.23-1968 veröffentlicht.
Der Ausschuss X3.4.4 wurde dann zum Technischen Komitee X3J4, wie er auch heute noch heißt, und machte sich an die Arbeit, den nächsten Standard zu entwickeln, der dann am 10. Mai 1974 als American National Standard COBOL 1974 verabschiedet und dann im Dokument ANS X3.23-1974 veröffentlicht wurde.
Der nächste Standard wurde im April 1985 von X3J4 verabschiedet und im September vom zuständigen Entscheidungsgremium der inzwischen ANSI heißenden Organisation angenommen und dann als ANS X3.23-1985 veröffentlicht. COBOL-85 führte mit Begrenzern wie END-IF und END-PERFORM erstmals die Möglichkeit ein, in COBOL beliebig geschachtelte Entscheidungs- (IF, EVALUATE) und Wiederholungsanweisungen (PERFORM) zu schreiben und damit die sogenannte strukturierte Programmierung in COBOL zu praktizieren. Zu COBOL-85 wurde später ein Zusatz mit eingebauten (intrinsic) Funktionen und ein weiterer mit Korrekturen zum Standard veröffentlicht.
Ein neuer Standard wurde 2002 verabschiedet. Wesentliche Änderungen darin sind die Übernahme der Erweiterungen durch X/Open, die explizite Unterstützung von internationalen Zeichensätzen einschließlich Unicode, die objektorientierte Programmierung sowie bedingte Kompilierung, neben zahlreichen anderen Erweiterungen und Präzisierungen.
Nach dem Ende von CODASYL hat das Komitee J4 auch die Verantwortung nicht nur für die Standardisierung, sondern auch für die Entwicklung übernommen.
Der nächste Standard wurde für das Jahr 2010 vorbereitet und wurde 2014 veröffentlicht.
Internationale Standardisierung bei ISO
[Bearbeiten | Quelltext bearbeiten]Das Komitee X3J4 (früher X3.4.4) hat von Anfang an eng mit verschiedenen internationalen Gremien zusammengearbeitet. Dementsprechend stimmte ANS COBOL X3.23-1968 mit der ISO-Empfehlung für COBOL überein.
In der ISO ist das Technical Committee ISO/TC 97, Computers and Information Processing zuständig, dessen Sekretariat vom ANSI gestellt wird.
ISO hat zu COBOL eine Empfehlung (Recommendation) R-1989:1972 sowie Standards ISO 1989:1978 und ISO 1989:1985 verabschiedet und dabei die Vorgabe des US-Standardisierungsgremiums übernommen.
2002 wurde ein weiterer Standard umgekehrt zuerst als ISO/IEC 1989:2002 veröffentlicht und dann von den nationalen Standardorganisationen übernommen. Dieser wurde 2014 als ISO/IEC 1989:2014 erweitert.
Der aktuelle Standard wurde im Januar 2023 als ISO/IEC 1989:2023 veröffentlicht.
Module und standardkonforme Implementierungen
[Bearbeiten | Quelltext bearbeiten]COBOL-68, COBOL-74 und COBOL-85 ordneten die verschiedenen Features der Sprache einem Modul mit jeweils einem bis drei „Levels“ zu, woraus dann minimale und volle Implementierungen des Standards als Kombination von bestimmten Levels der jeweiligen Module definiert wurden. Eine mit COBOL-2002 konforme Implementierung muss den gesamten Sprachumfang implementieren.
COBOL-Compiler
[Bearbeiten | Quelltext bearbeiten]Für Computer der Klassen „Großrechner“ und „Mittlere Datentechnik“ boten und bieten deren jeweilige Hersteller – IBM, Unisys, Siemens, Fujitsu-Siemens, HP, Bull u. a. – auf ihre proprietären Betriebssysteme zugeschnittene COBOL-Compiler an, z. T. verschiedene Compiler, die beispielsweise verschiedenen Standards entsprechen.
Für Betriebssysteme, die aus der UNIX- bzw. MS-DOS-Tradition entstanden sind, gibt es COBOL-Compiler von verschiedenen Software-Herstellern. Mit GnuCOBOL existiert eine quelloffene Implementierung der Programmiersprache.[10]
COBOL-Generatoren
[Bearbeiten | Quelltext bearbeiten]Es gibt Codegeneratoren, die COBOL-Programme bzw. Teile davon generieren und so die Entwicklungsarbeit erleichtern. Dazu gehören zum Beispiel SWT01 und SWT/VDA des Herstellers FSP, CA Gen (ehemals Cool:Gen) von CA Technologies, sowie die Generatorsysteme ADSplus und SCORE von Delta Software Technology.
Literatur
[Bearbeiten | Quelltext bearbeiten]- Franck Barbier, Jean-Luc Recoussine: COBOL Software Modernization, iSTE Wiley, 1. Auflage 2015, ISBN 1-84821-760-9
- Michael Coughlan: Beginning COBOL for Programmers, Apress, 1. Auflage 2014, ISBN 1-4302-6253-2
- Nancy B. Stern, Robert A. Stern u. James P. Ley: COBOL for the 21st Century,
John Wiley & Sons, 11. Auflage 2013, ISBN 1-118-73953-1
Weblinks
[Bearbeiten | Quelltext bearbeiten]- COBOL-Beispiele aus der Praxis von heute
- Handbücher zu ILE COBOL
- ISO/IEC 1989:2023
Einzelnachweise
[Bearbeiten | Quelltext bearbeiten]- ↑ www.iso.org.
- ↑ Martin Reusch: COBOL 2022 – So relevant wie nie?! In: it-daily.net. 11. April 2022, abgerufen am 15. August 2023.
- ↑ a b Kathrin Stoll: Senior Programmer händeringend gesucht – für 60 Jahre alte Programmiersprache – t3n – digital pioneers. Abgerufen am 23. April 2020 (deutsch).
- ↑ WDR ( vom 8. Juni 2016 im Internet Archive)
- ↑ Grace Hopper, aufgerufen am 8. Juni 2016
- ↑ "Covid-19: Warum in den USA plötzlich wieder Cobol-Programmierer gebraucht werden" der Standard vom 6. April 2020
- ↑ Manager Magazin: Programmierer mit 70 Jahren oder älter dringend gesucht, abgerufen am 23. Mai 2020.
- ↑ IT-Finanz-Magazin; COBOL wird sechzig – Evergreen mit Nachwuchssorgen, abgerufen am 23. Mai 2020.
- ↑ COBOL, soweit das Auge reicht: über 800 Milliarden Zeilen Code im Einsatz (vom 4. Februar 2022; abgerufen am 23. Februar 2024) auf IT Finanzmagazin
- ↑ GnuCOBOL (formerly OpenCOBOL). Abgerufen am 27. Dezember 2016.