Wikipedia

Makroprozessor

Prozessortyp

Als Makroprozessoren werden Computerprogramme bezeichnet, die Zeichenfolgen innerhalb eines Textes durch andere Zeichenfolgen ersetzen. Eine Zeichenfolge mit ihrem Ersatztext nennt man Makro. Makros sind normalerweise parametrisierbar. Die meisten Makroprozessoren kennen einige Befehle: In der Regel dient zum Beispiel define zum Festlegen von Makros. Andere Befehle erlauben oft Zeichenkettenverarbeitung, bedingten Textersatz, Schreiben und Lesen von Hilfsdateien usw. Mitunter können Befehle und Makros sehr ähnlich verarbeitet werden.

Ein bekannter Makroprozessor ist z. B. Teil des Textsatzprogramms TeX. Auch der C-Präprozessor der Sprache C ist ein Makroprozessor.

Der m4-Makroprozessor als Beispiel

Bearbeiten

Das Betriebssystem Unix enthält standardmäßig den Makroprozessor m4. Dieser erlaubt über den Makro define die Definition eigener Makros. 

    define(`H',`Hans')define(`U',`und')define(`I',`Inge')dnl
    H U I, I U H. H liebt I.

ergibt

  • Hans und Inge, Inge und Hans. Hans liebt Inge.

Die Zeichen ` (auf einer deutschen Tastatur rechts neben dem Fragezeichen) und ' (rechts neben dem Ä) sorgen dafür, dass Makros nicht ersetzt werden, wenn sie innerhalb eines Teils sind, der mit ` beginnt und mit ' endet.

Über viele weitere eingebaute Makros wie eval, ifelse lassen sich Ausdrücke und Bedingungen implementieren. Wiederholungen und Schleifen können durch Rekursion erreicht werden.

Vordefinierte Makros im Makroprozessor m4 (Auswahl)
Makro Beschreibung
define(`name',def) Definition des neuen Makros name, Ersatz mit def
eval Auswertung eines arithmetischen Ausdrucks
incr Erhöhen des Arguments um eins
ifdef Bedingte Ausführung
divert(-1) Unterdrückung der Ausgabe
dnl Unterdrückung des Rests der Zeile (einschließlich Zeilentrenner)
include(`Datei') Text aus Datei einlesen und interpretieren.
$1, $2, … Parameter, die innerhalb von def in einer Makrodefinition verwendet werden können und die dann durch den Text des aktuellen Parameters bei Aufruf ersetzt werden.

Mit einem Makroprozessor lassen sich zum Beispiel automatische Zähler implementieren: 

define(`Zaehler',`define(`$1',incr($1))Kapitel $1.')dnl
define(`kapitelnr',0)dnl
Zaehler(`kapitelnr')
Zaehler(`kapitelnr')
Zaehler(`kapitelnr')
Zaehler(`kapitelnr')

Wird dieses Beispiel mit m4 bearbeitet, so erhält man die folgende Ausgabe: 

Kapitel 1.
Kapitel 2.
Kapitel 3.
Kapitel 4.

Damit lassen sich z. B. Kapitel- und Abschnittsnummern in einem Text automatisch hochzählen: 

divert(-1)dnl
  define(`Zaehler',`define(`$1',incr($1))$1')
  define(`kapitelnr',0)
  define(`abschnittnr',0)
  define(`Kapitel',`<h1>Zaehler(`kapitelnr'). $1</h1>define(`abschnittnr',0)')
  define(`Abschnitt',`<h2>kapitelnr.Zaehler(`abschnittnr') $1</h2>')
divert(0)dnl

Kapitel(Einführung)
Dieser Text handelt von …
Abschnitt(Geschichte)
Geschichtlich ist folgendes zu sagen …
Abschnitt(Neuere Entwicklungen)
Doch in neuerer Zeit ergeben sich …
Kapitel(Definitionen)
Abschnitt(Zahlenwerte)
…
Abschnitt(Konstanten)
…
Abschnitt(Variablen)
…

Die Ausgabe von m4 ist dann 

  <h1>1. Einführung</h1>
  Dieser Text handelt von …
  <h2>1.1 Geschichte</h2>
  Geschichtlich ist folgendes zu sagen …
  <h2>1.2 Neuere Entwicklungen</h2>
  Doch in neuerer Zeit ergeben sich …
  <h1>2. Definitionen</h1>
  <h2>2.1 Zahlenwerte</h2>
  … …
  <h2>2.2 Konstanten</h2>
  … …
  <h2>2.3 Variablen</h2>
  … …

Der Makroprozessor als Präprozessor

Bearbeiten

Ein Makroprozessor stellt eine Form von Präprozessor (Vor-Prozessor) dar. Er verändert einen Eingabetext bevor der Benutzer diesen dem eigentlichen Verarbeitungsprogramm übergibt.

Unter Unix lassen sich viele Makroprozessoren in der Kommandozeile als eigene Prozesse aufrufen, die Weitergabe des verarbeiteten Texts geschieht über eine Pipe:

  $ m4 diplomarbeit.txt | tbl | eqn | groff -mt -Tps | kprinter

Hier wird die Datei diplomarbeit.txt zunächst vom Makroprozessor m4 bearbeitet, danach vom Tabellenprozessor tbl und vom Formelsatz-Prozessor eqn (beides Makroprozessoren), um dann vom Textsatz-(Makro-)Prozessor groff in die Sprache Postscript gewandelt zu werden. kprinter kann danach das Ergebnis auf einem Postscript-fähigen Drucker ausgeben.

Der C-Präprozessor

Bearbeiten

Die Programmiersprache C enthält einen einfachen Makroprozessor, den C-Präprozessor. Dieser kann für die folgenden Aufgaben eingesetzt werden:

  • Definition von symbolischen Konstanten
  • Bedingte Übersetzung
  • Erweiterung der Sprache durch einfache Sprachkonstrukte
  • Vereinfachung der Schreibarbeit
Befehle des C-Präprozessors (Auswahl)
Makro Beschreibung
#define name Ersatztext Definition des neuen Makros name. Tritt name im Text auf, wird es durch den Ersatztext ersetzt.
#define name(p1,p2) txt Definition des neuen Makros name mit den Parametern p1 und p2. Innerhalb von txt werden die Zeichenfolgen p1 und p2 durch den jeweiligen Text der aktuellen Parameter ersetzt.
#ifdef name
#else
#endif 		Bedingte Übersetzung. Die Zeilen zwischen den Makros werden nur übersetzt, wenn ein Makro name existiert oder nicht.
__FILE__
__LINE__ 		Name und Zeilennummer der Datei, die den Programmtext enthält.
__unix__ Vordefiniert unter Unix-Betriebssystemen, undefiniert unter anderen Systemen.
#include <datei>
#include "datei" 		Datei einlesen und Text in die Ausgabe einfügen.

Die Möglichkeiten des C-Präprozessors sind relativ eingeschränkt. Er gibt der Sprache jedoch eine zusätzliche Flexibilität, die von anderen Sprachen kaum erreicht wird. Allerdings führt das in komplexen Programmsystemen auch zu Schwierigkeiten mit der Wartung und Pflege einheitlicher Definitionen, weshalb nachfolgend entwickelte Programmiersprachen teilweise bewusst auf dieses Konzept verzichtet hatten.

Im folgenden Programmbeispiel 

  #define FIELDSIZE 100

  int Feld[FIELDSIZE];
  main() {
     int i;
     Feld[0] = 0; Feld[1] = 1;
     for (i = 2; i < FIELDSIZE;   i)
        Feld[i] = Feld[i-1]   Feld[i-2];
  }

wird FIELDSIZE einfach durch 100 ersetzt: 

  int Feld[100];
  main() {
     int i;
     Feld[0] = 0; Feld[1] = 1;
     for (i = 2; i < 100;   i)
        Feld[i] = Feld[i-1]   Feld[i-2];
  }

Erst dadurch entsteht ein Programmtext, den der eigentliche C-Compiler fehlerfrei übersetzen kann.[1]

Das folgende Programm ermittelt, ob es unter Unix kompiliert worden ist. Andernfalls wird auf eine Eingabe gewartet: 

  #include <stdio.h>
  main() {
     printf("Das Programm läuft ");
  #ifdef __UNIX__
     printf("unter Unix.\n");
  #else
     printf("unter einem unbekannten Betriebssystem.\n");
     printf("Bitte drücken Sie eine Taste!");
     getchar();
  #endif
  }

Ein Unix-Compiler würde hier den folgenden Text übersetzen: 

  main() {
     printf("Das Programm läuft ");
     printf("unter Unix.\n");
  }

Ein Compiler eines unbekannten Betriebssystems würde dagegen das folgende Programm übersetzen: 

  main() {
     printf("Das Programm läuft ");
     printf("unter einem unbekannten Betriebssystem.\n");
     printf("Bitte drücken Sie eine Taste!");
     getchar();
  }

Der C-Makroprozessor ist jedoch viel einfacher als der m4-Prozessor. Er erlaubt keine rekursiven Aufrufe, Schleifen oder Auswertung von Ausdrücken.

TeX und LaTeX

Bearbeiten

Der Makroprozessor des Textsatzprogramms TeX kann für benutzerdefinierte Erweiterungen verwendet werden. Das Makropaket LaTeX von Leslie Lamport stellt eine verbreitete Erweiterung dar. Statt define werden neue Makros durch newcommand definiert.

Einen Teil eines CD-Covers zeigt das folgende Beispiel: 

 \documentclass[landscape,dvips]{article}
 \usepackage{cd-cover}

 \newcommand{\lied}[4]{
 \small{\textsf{#1}} & \small{\textsf{#2}}
                     & \small{\textsf{#3}}
                     & \small{\textsf{#4}} \\}
 \begin{document}
 %[...]
 \begin{tabular}{l l l l}
 \lied{1} {Neneh Cherry}
          {Woman}
          {04:10}
 \lied{2} {Luz Casal}
          {Piensa en mi}
          {04:27}
 %[...]
 \lied{14}{Axelle Red}
          {Rester femme}
          {05:01}
 \end{tabular}

 \end{document}

MediaWiki

Bearbeiten

Die Wiki-Engine MediaWiki enthält einen Makroprozessor. Hierzu werden Vorlagenseiten (engl. template) erstellt, die dann inklusive Parametern in eine Seite eingebunden werden können.

Siehe auch

Bearbeiten

Anmerkungen

Bearbeiten
  1. ↑ Tatsächlich erfolgt seit Jahrzehnten die Verarbeitung aber nicht mehr in zwei aufeinanderfolgenden Schritten (sofern der Benutzer das Ergebnis des Preprocessing nicht ausdrücklich als Ausgabe zu sehen wünscht), sondern in einem Durchgang während der Kompilierung.
Abgerufen von „https://de.wikipedia.org/w/index.php?title=Makroprozessor&oldid=234749879“