Makro (Informatik) – Wikipedia

Posted on by

In der Informatik eine prägnante Darstellung eines Musters

EIN Makro (kurz für “Makroinstruktion”, aus dem Griechischen Kombinationsform μακρο- ‘lang groß’[1]) in der Informatik ist eine Regel oder ein Muster, das angibt, wie eine bestimmte Eingabe auf eine Ersatzausgabe abgebildet werden soll. Das Anwenden eines Makros auf eine Eingabe ist Makroerweiterung. Die Eingabe und Ausgabe kann eine Folge lexikalischer Token oder Zeichen oder ein Syntaxbaum sein. Zeichenmakros werden in Softwareanwendungen unterstützt, um das Aufrufen allgemeiner Befehlssequenzen zu vereinfachen. Token- und Baummakros werden in einigen Programmiersprachen unterstützt, um die Wiederverwendung von Code zu ermöglichen oder die Sprache zu erweitern, manchmal für domänenspezifische Sprachen.

Makros werden verwendet, um dem Programmierer eine Folge von Rechenanweisungen als eine einzige Programmanweisung zur Verfügung zu stellen, wodurch die Programmieraufgabe weniger mühsam und weniger fehleranfällig wird.[2][3] (Daher werden sie “Makros” genannt, weil ein “großer” Codeblock aus einer “kleinen” Zeichenfolge erweitert werden kann.) Makros ermöglichen oft Positions- oder Schlüsselwortparameter, die bestimmen, was das bedingte Assemblerprogramm generiert und wofür es verwendet wurde Erstellen Sie ganze Programme oder Programmpakete nach Variablen wie Betriebssystem, Plattform oder anderen Faktoren. Der Begriff leitet sich von “Makroanweisung” ab, und solche Erweiterungen wurden ursprünglich beim Generieren von Assemblersprachcode verwendet.

Tastatur- und Mausmakros[edit]

Tastaturmakros und Mausmakros ermöglichen, dass kurze Tastenanschläge und Mausaktionen in andere, normalerweise zeitaufwendigere Tastenanschläge und Mausaktionen umgewandelt werden. Auf diese Weise lassen sich häufig verwendete oder sich wiederholende Tasten- und Mausbewegungen automatisieren. Separate Programme zum Erstellen dieser Makros werden Makrorekorder genannt.

In den 1980er Jahren waren Makroprogramme – ursprünglich SmartKey, dann SuperKey, KeyWorks, Prokey – sehr beliebt, zuerst als Mittel zur automatischen Formatierung von Drehbüchern, dann für eine Vielzahl von Benutzereingabeaufgaben. Diese Programme basierten auf dem TSR-Betriebsmodus (Terminate and Stay Resident) und wurden auf alle Tastatureingaben angewendet, egal in welchem ​​Kontext sie erfolgten. Mit dem Aufkommen von mausgesteuerten Benutzeroberflächen und der Verfügbarkeit von Tastatur- und Mausmakros in Anwendungen wie Textverarbeitungen und Tabellenkalkulationen, die es ermöglichen, anwendungssensitive Tastaturmakros zu erstellen, sind sie teilweise obsolet geworden.

Tastaturmakros können in Massively Multiplayer Online Role-Playing Games (MMORPGs) verwendet werden, um sich wiederholende, aber lukrative Aufgaben auszuführen und so Ressourcen anzuhäufen. Da dies ohne menschliches Zutun geschieht, kann dies die Wirtschaftlichkeit des Spiels beeinträchtigen. Aus diesem Grund stellt die Verwendung von Makros einen Verstoß gegen die Nutzungsbedingungen oder EULA der meisten MMORPGs dar, und ihre Administratoren unternehmen erhebliche Anstrengungen, um sie zu unterdrücken.[4]

Anwendungsmakros und Skripterstellung[edit]

Tastatur- und Mausmakros, die mit den integrierten Makrofunktionen einer Anwendung erstellt wurden, werden manchmal als . bezeichnet Anwendungsmakros. Sie werden erstellt, indem die Sequenz einmal ausgeführt wird und die Anwendung die Aktionen aufzeichnen lässt. Es kann auch eine zugrunde liegende Makroprogrammiersprache, am häufigsten eine Skriptsprache, mit direktem Zugriff auf die Funktionen der Anwendung existieren.

Der Texteditor der Programmierer, Emacs, (kurz für “Editing Macros”) folgt dieser Idee zu einem Schluss. Tatsächlich besteht der Editor größtenteils aus Makros. Emacs wurde ursprünglich als Satz von Makros in der Bearbeitungssprache TECO entwickelt; es wurde später auf Dialekte von Lisp portiert.

Der Texteditor eines anderen Programmierers, Vim (ein Nachkomme von vi), hat ebenfalls eine Implementierung von Tastaturmakros. Es kann in ein Register (Makro) aufnehmen, was eine Person auf der Tastatur tippt, und es kann wie VBA-Makros für Microsoft Office wiedergegeben oder bearbeitet werden. Vim hat auch eine Skriptsprache namens Vimscript[5] Makros zu erstellen.

Visual Basic for Applications (VBA) ist eine Programmiersprache, die in Microsoft Office von Office 97 bis Office 2019 enthalten ist (obwohl sie in einigen Komponenten von Office vor Office 97 verfügbar war). Seine Funktion hat sich jedoch aus den Makrosprachen entwickelt und ersetzt, die ursprünglich in einigen dieser Anwendungen enthalten waren.

XEDIT, das auf der Conversational Monitor System (CMS)-Komponente von VM ausgeführt wird, unterstützt Makros, die in EXEC, EXEC2 und REXX geschrieben wurden, und einige CMS-Befehle waren tatsächlich Wrapper um XEDIT-Makros. Der Hessling Editor (THE), ein Teilklon von XEDIT, unterstützt Rexx-Makros mit Regina und Open Object REXX (oorexx). Viele gängige Anwendungen und einige auf PCs verwenden Rexx als Skriptsprache.

Makrovirus[edit]

VBA hat Zugriff auf die meisten Microsoft Windows-Systemaufrufe und wird ausgeführt, wenn Dokumente geöffnet werden. Dies macht es relativ einfach, Computerviren in VBA zu schreiben, die allgemein als Makroviren bekannt sind. Mitte bis Ende der 1990er Jahre wurde dies zu einer der häufigsten Arten von Computerviren. In den späten 1990er Jahren und bis heute hat Microsoft jedoch seine Programme gepatcht und aktualisiert. Zudem wirken aktuelle Antivirenprogramme solchen Angriffen sofort entgegen.

Parametriertes Makro[edit]

EIN parametrisiertes Makro ist ein Makro, das in der Lage ist, vorgegebene Objekte in seine Erweiterung einzufügen. Dies gibt dem Makro einen Teil der Leistungsfähigkeit einer Funktion.

Als einfaches Beispiel ist dies in der Programmiersprache C ein typisches Makro, das nicht ein parametrisiertes Makro: 

 #define PI   3.14159

Dies bewirkt PI immer ersetzt werden durch 3.14159 wo immer es auftritt. Ein Beispiel für ein parametrisiertes Makro hingegen ist folgendes: 

 #define pred(x)  ((x)-1)

Auf was dieses Makro erweitert wird, hängt davon ab, welches Argument x wird daran weitergegeben. Hier einige mögliche Erweiterungen: 

 pred(2)    →  ((2)   -1)
 pred(y+2)  →  ((y+2) -1)
 pred(f(5)) →  ((f(5))-1)

Parametrisierte Makros sind ein nützlicher Mechanismus auf Quellebene, um eine Inline-Erweiterung durchzuführen, aber in Sprachen wie C, in denen sie eine einfache Textersetzung verwenden, haben sie eine Reihe schwerwiegender Nachteile gegenüber anderen Mechanismen zur Durchführung einer Inline-Erweiterung, wie z. B. Inline-Funktionen .

Die parametrisierten Makros, die in Sprachen wie Lisp, PL/I und Scheme verwendet werden, sind dagegen viel mächtiger und können auf der Grundlage ihrer Argumente Entscheidungen darüber treffen, welcher Code erstellt werden soll; daher können sie effektiv verwendet werden, um eine Laufzeitcodegenerierung durchzuführen.

Makros zur Textersetzung[edit]

Sprachen wie C und einige Assemblersprachen haben rudimentäre Makrosysteme, die als Präprozessoren für den Compiler oder Assembler implementiert sind. C-Präprozessormakros funktionieren durch einfache Textersetzung auf Token- und nicht auf Zeichenebene. Allerdings können die Makrofunktionen komplexerer Assembler, zB IBM High Level Assembler (HLASM), nicht mit einem Präprozessor implementiert werden; der Code zum Zusammensetzen von Anweisungen und Daten wird mit dem Code zum Zusammensetzen von Makroaufrufen durchsetzt.

Eine klassische Verwendung von Makros findet sich im Computersatzsystem TeX und seinen Derivaten, wo der Großteil der Funktionalität auf Makros basiert.

MacroML ist ein experimentelles System, das versucht, statische Typisierung und Makrosysteme in Einklang zu bringen. Nemerle hat Syntaxmakros typisiert, und eine produktive Art, sich diese Syntaxmakros als mehrstufige Berechnung vorzustellen.

Andere Beispiele:

  • m4 ist ein hochentwickelter eigenständiger Makroprozessor.
  • TRAC
  • Makroerweiterung TAL, begleitende Template-Attributsprache
  • SMX: für Webseiten
  • ML/1 (Makrosprache Eins)
  • Der General Purpose Macroprocessor ist ein kontextueller Mustervergleichs-Makroprozessor, der als Kombination aus regulären Ausdrücken, EBNF und AWK . beschrieben werden könnte[citation needed]
  • SAM76
  • troff und nroff: zum Setzen und Formatieren von Unix-Manpages.
  • CMS EXEC: für Kommandozeilen- und Anwendungsmakros
  • EXEC 2 im Conversational Monitor System (CMS): für Befehlszeilen- und Anwendungsmakros
  • CLIST in IBMs Time Sharing Option (TSO): für Befehlszeilen- und Anwendungsmakros
  • REXX: für Kommandozeilen-Makros und Anwendungsmakros in zB AmigaOS, CMS, OS/2, TSO
  • SKRIPT: zum Formatieren von Dokumenten
  • Verschiedene Shells für zB Linux

Einige Hauptanwendungen wurden als Textmakro geschrieben, die von anderen Anwendungen aufgerufen werden, zB von XEDIT im CMS.

Einbettbare Sprachen[edit]

Einige Sprachen wie PHP können in frei formatierten Text oder den Quellcode anderer Sprachen eingebettet werden. Der Mechanismus, mit dem die Codefragmente erkannt werden (z. B. durch Einklammern von und ?>) ähnelt einer textuellen Makrosprache, aber sie sind viel leistungsfähigere Sprachen mit vollem Funktionsumfang.

Prozedurale Makros[edit]

Makros in der PL/I-Sprache werden in einer Teilmenge von PL/I selbst geschrieben: Der Compiler führt zur Kompilierungszeit "Präprozessor-Anweisungen" aus, und die Ausgabe dieser Ausführung ist Teil des kompilierten Codes. Die Fähigkeit, eine vertraute prozedurale Sprache als Makrosprache zu verwenden, bietet eine viel größere Leistungsfähigkeit als die von Textersetzungsmakros, auf Kosten eines größeren und langsameren Compilers.

Die Frame-Makros der Frame-Technologie haben ihre eigene Befehlssyntax, können aber auch Text in jeder Sprache enthalten. Jeder Rahmen ist sowohl eine generische Komponente in einer Hierarchie verschachtelter Unterbaugruppen als auch ein Verfahren zum Integrieren in seine Unterbaugruppenrahmen (ein rekursiver Prozess, der Integrationskonflikte zugunsten von Unterbaugruppen höherer Ebene löst). Die Ausgaben sind benutzerdefinierte Dokumente, normalerweise kompilierbare Quellmodule. Die Frame-Technologie kann die Verbreitung ähnlicher, aber subtil unterschiedlicher Komponenten vermeiden, ein Problem, das die Softwareentwicklung seit der Erfindung von Makros und Subroutinen quält.

Die meisten Assemblersprachen verfügen über weniger leistungsfähige prozedurale Makrofunktionen, die beispielsweise erlauben, dass ein Codeblock N-mal wiederholt wird, um eine Schleife aufzurollen; Diese haben jedoch eine völlig andere Syntax als die eigentliche Assemblersprache.

Syntaktische Makros[edit]

Makrosysteme – wie der zuvor beschriebene C-Präprozessor –, die auf der Ebene lexikalischer Token arbeiten, können die lexikalische Struktur nicht zuverlässig bewahren. Syntaktische Makrosysteme arbeiten stattdessen auf der Ebene abstrakter Syntaxbäume und bewahren die lexikalische Struktur des Originalprogramms. Die am weitesten verbreiteten Implementierungen syntaktischer Makrosysteme finden sich in Lisp-ähnlichen Sprachen. Diese Sprachen eignen sich aufgrund ihrer einheitlichen Syntax in Klammern (bekannt als S-Ausdrücke) besonders für diesen Makrostil. Insbesondere die einheitliche Syntax erleichtert die Bestimmung der Aufrufe von Makros. Lisp-Makros transformieren die Programmstruktur selbst, wobei die vollständige Sprache verfügbar ist, um solche Transformationen auszudrücken. Während syntaktische Makros oft in Lisp-ähnlichen Sprachen zu finden sind, sind sie auch in anderen Sprachen wie Prolog,[6]Erlang,[7]Dylan,[8]Scala,[9]Nemerle,[10]Rost,[11]Elixier,[12]Nim,[13]Haxe,[14] und Julia.[15] Sie sind auch als JavaScript-Erweiterungen von Drittanbietern verfügbar.[16]C#[17] und Python.[18]

Frühe Lisp-Makros[edit]

Bevor Lisp Makros hatte, gab es sogenannte FEXPRs, funktionsähnliche Operatoren, deren Eingaben nicht die von den Argumenten berechneten Werte waren, sondern die syntaktischen Formen der Argumente, und deren Ausgabe Werte waren, die in der Berechnung verwendet werden sollten. Mit anderen Worten, FEXPRs wurden auf der gleichen Ebene wie EVAL implementiert und boten ein Fenster in die Meta-Evaluierungsschicht. Dies erwies sich im Allgemeinen als ein schwieriges Modell, um effektiv zu argumentieren.[19]

1963 schlug Timothy Hart vor, in AI Memo 57: MACRO Definitions for LISP Makros zu Lisp 1.5 hinzuzufügen.[20]

Anaphorische Makros[edit]

Ein anaphorisches Makro ist eine Art von Programmiermakro, das absichtlich eine dem Makro zugeführte Form erfasst, auf die durch ein Anapher (ein Ausdruck, der sich auf ein anderes bezieht) Bezug genommen werden kann. Anaphorische Makros tauchten erstmals in Paul Grahams On Lisp auf und ihr Name ist ein Hinweis auf linguistische Anaphora – die Verwendung von Wörtern als Ersatz für vorangehende Wörter.

Hygienische Makros[edit]

Mitte der achtziger Jahre eine Reihe von Papieren[21][22] führte den Begriff der hygienischen Makroerweiterung ein (syntax-rules), ein musterbasiertes System, bei dem die syntaktischen Umgebungen der Makrodefinition und der Makroverwendung unterschiedlich sind, was es Makrodefinierern und Benutzern ermöglicht, sich keine Sorgen über eine unbeabsichtigte Variablenerfassung zu machen (vgl. referenzielle Transparenz). Hygienische Makros wurden für Scheme in den Standards R5RS, R6RS und R7RS standardisiert. Es gibt eine Reihe konkurrierender Implementierungen von Hygienemakros, wie z syntax-rules, syntax-case, explizite Umbenennung und syntaktische Schließungen. Beide syntax-rules und syntax-case wurden in den Scheme-Standards standardisiert.

Vor kurzem hat Racket die Begriffe hygienischer Makros mit einem "Turm von Bewertern" kombiniert, so dass die syntaktische Expansionszeit eines Makrosystems die normale Laufzeit eines anderen Codeblocks ist.[23] und zeigte, wie man verschachtelte Erweiterung und Parsing in einer Sprache ohne Klammern anwendet.[24]

Eine Reihe anderer Sprachen als Scheme implementieren entweder hygienische Makros oder implementieren teilweise hygienische Systeme. Beispiele sind Scala, Rust, Elixir, Julia, Dylan, Nim und Nemerle.

Anwendungen[edit]

Bewertungsauftrag
Makrosysteme haben eine Reihe von Anwendungen. Die Wahl der Auswertungsreihenfolge (siehe Lazy-Evaluation und nicht-strikte Funktionen) ermöglicht die Erstellung neuer syntaktischer Konstrukte (zB Kontrollstrukturen), die von den in die Sprache eingebauten nicht zu unterscheiden sind. Zum Beispiel in einem Lisp-Dialekt mit cond aber fehlt if, ist es möglich, letztere in Bezug auf erstere mit Hilfe von Makros zu definieren. Scheme hat zum Beispiel sowohl Fortsetzungen als auch Hygienemakros, die es einem Programmierer ermöglichen, ihre eigenen Kontrollabstraktionen wie Schleifen und Konstrukte für frühes Verlassen zu entwerfen, ohne sie in die Sprache einbauen zu müssen.
Datenuntersprachen und domänenspezifische Sprachen
Darüber hinaus ermöglichen Makros die Definition von Datensprachen, die sofort in Code übersetzt werden, wodurch Konstrukte wie Zustandsautomaten auf natürliche und effiziente Weise implementiert werden können.[25]
Bindungskonstrukte
Makros können auch verwendet werden, um neue Bindungskonstrukte einzuführen. Das bekannteste Beispiel ist die Transformation von let in die Anwendung einer Funktion auf eine Reihe von Argumenten.

Felleisen-Vermutungen[26] dass diese drei Kategorien die primären legitimen Verwendungen von Makros in einem solchen System darstellen. Andere haben alternative Verwendungen von Makros vorgeschlagen, wie beispielsweise anaphorische Makros in Makrosystemen, die unhygienisch sind oder eine selektive unhygienische Transformation ermöglichen.

Die Interaktion von Makros und anderen Sprachmerkmalen war ein produktives Forschungsgebiet. Komponenten und Module sind beispielsweise für umfangreiche Programmierungen nützlich, aber das Zusammenspiel von Makros und diesen anderen Konstrukten muss für ihre gemeinsame Verwendung definiert werden. Modul- und Komponentensysteme, die mit Makros interagieren können, wurden für Scheme und andere Sprachen mit Makros vorgeschlagen. Zum Beispiel erweitert die Sprache Racket den Begriff eines Makrosystems auf einen syntaktischen Turm, in dem Makros in Sprachen einschließlich Makros geschrieben werden können, wobei Hygiene verwendet wird, um sicherzustellen, dass syntaktische Schichten unterschiedlich sind, und es Modulen ermöglicht, Makros in andere Module zu exportieren.

Makros für maschinenunabhängige Software[edit]

Makros werden normalerweise verwendet, um einen kurzen String (Makroaufruf) auf eine längere Befehlsfolge abzubilden. Eine andere, weniger verbreitete Verwendung von Makros besteht darin, das Gegenteil zu tun: eine Folge von Anweisungen einer Makrozeichenfolge zuzuordnen. Dies war der Ansatz des STAGE2 Mobile Programming System, das einen rudimentären Makro-Compiler (genannt SIMCMP) verwendet, um den spezifischen Befehlssatz eines bestimmten Computers auf das Gegenstück abzubilden maschinenunabhängig Makros. Anwendungen (insbesondere Compiler), die in diesen maschinenunabhängigen Makros geschrieben sind, können dann ohne Änderung auf jedem Computer ausgeführt werden, der mit dem rudimentären Makro-Compiler ausgestattet ist. Die erste Anwendung, die in einem solchen Kontext ausgeführt wird, ist ein komplexerer und leistungsfähigerer Makro-Compiler, der in der maschinenunabhängigen Makrosprache geschrieben ist. Dieser Makro-Compiler wird auf Bootstrap-Art auf sich selbst angewendet, um eine kompilierte und viel effizientere Version von sich selbst zu erzeugen. Der Vorteil dieses Ansatzes besteht darin, dass komplexe Anwendungen mit sehr geringem Aufwand (für jede Zielmaschinenarchitektur nur das Schreiben des rudimentären Makro-Compilers) von einem Rechner auf einen ganz anderen Rechner portiert werden können.[27][28] Das Aufkommen moderner Programmiersprachen, insbesondere C, für die Compiler auf praktisch allen Computern verfügbar sind, hat einen solchen Ansatz überflüssig gemacht. Dies war jedoch eine der ersten Instanzen (wenn nicht die erste) von Compiler-Bootstrapping.

Assemblersprache[edit]

Während Makroanweisungen kann von einem Programmierer für jeden Satz nativer Assembler-Programmanweisungen definiert werden, normalerweise sind Makros mit Makrobibliotheken verknüpft, die mit dem Betriebssystem geliefert werden und den Zugriff auf Betriebssystemfunktionen wie

  • Peripheriezugriff durch Zugriffsmethoden (einschließlich Makros wie OPEN, CLOSE, READ und WRITE)
  • Betriebssystemfunktionen wie ATTACH, WAIT und POST zur Erstellung und Synchronisation von Teilaufgaben.[29] Typischerweise werden solche Makros in ausführbaren Code erweitert, z. B. für den EXIT-Makrobefehl,
  • eine Liste von Konstante definieren Anweisungen, zB für das DCB-Makro – DTF (Define The File) für DOS[30]– oder eine Kombination aus Code und Konstanten, wobei die Details der Erweiterung von den Parametern des Makrobefehls abhängig sind (wie ein Verweis auf eine Datei und ein Datenbereich für einen READ-Befehl);
  • der ausführbare Code endet oft in a Filial- und Linkregister eine Anweisung zum Aufrufen einer Routine oder eine Supervisor-Aufrufanweisung zum direkten Aufrufen einer Betriebssystemfunktion.
  • Generieren von a Stufe 2 Jobstrom für die Systemgenerierung in zB OS/360. Im Gegensatz zu typischen Makros generieren sysgen-Stufe-1-Makros keine Daten oder Code, die in den Speicher geladen werden, sondern verwenden die SCHLAGEN -Anweisung zum Ausgeben von JCL und zugehörigen Daten.

In älteren Betriebssystemen wie denen, die auf IBM-Mainframes verwendet werden, war die volle Betriebssystemfunktionalität nur für Programme in Assembler-Sprache verfügbar, nicht für Hochsprachenprogramme (es sei denn, es wurden Subroutinen in Assembler-Sprache verwendet), da die Standard-Makrobefehle dies nicht immer taten haben Gegenstücke in Routinen, die für Hochsprachen verfügbar sind.

Geschichte[edit]

Mitte der 1950er Jahre, als Assemblerprogrammierung häufig verwendet wurde, um Programme für digitale Computer zu schreiben, wurde die Verwendung von Makroanweisungen wurde aus zwei Hauptgründen initiiert: um den Umfang des zu schreibenden Programmcodes zu reduzieren, indem mehrere Assembler-Anweisungen aus einem Makrobefehl generiert werden, und um Programmschreibstandards durchzusetzen, z.[31] Makrobefehle waren praktisch ein Mittelschritt zwischen der Assemblerprogrammierung und den folgenden höheren Programmiersprachen wie FORTRAN und COBOL. Zwei der frühesten Programmierinstallationen zur Entwicklung von "Makrosprachen" für den IBM 705-Computer waren bei Dow Chemical Corp. in Delaware und beim Air Material Command, Ballistics Missile Logistics Office in Kalifornien. Ein im Format der Zielassemblersprache geschriebener Makrobefehl würde von einem Makrocompiler verarbeitet, der ein Vorprozessor des Assemblers war, um einen oder mehrere Assemblerbefehle zu erzeugen, die als nächstes von dem Assemblerprogramm verarbeitet werden, das die Anweisungen in Assemblersprache in Anweisungen in Maschinensprache umwandeln.[32]

In den späten 1950er Jahren folgten der Makrosprache die Makroassembler. Dies war eine Kombination aus beidem, wobei ein Programm beide Funktionen erfüllte, die eines Makro-Präprozessors und eines Assemblers im selben Paket.[32][failed verification]

1959 führten Douglas E. Eastwood und Douglas McIlroy von Bell Labs bedingte und rekursive Makros in den beliebten SAP-Assembler ein.[33] Erstellung eines sogenannten Makro-SAP.[34] McIlroys Aufsatz aus dem Jahr 1960 war wegweisend auf dem Gebiet der Erweiterung beliebiger (einschließlich höherer) Programmiersprachen durch Makroprozessoren.[35][33]

Makro-Assembler ermöglichten es Programmierern in Assembler, ihre eigene Makrosprache zu implementieren, und erlaubten eine begrenzte Portabilität des Codes zwischen zwei Computern, auf denen dieselbe CPU, aber unterschiedliche Betriebssysteme laufen, zum Beispiel frühe Versionen von MSDOS und CPM-86. Die Makrobibliothek müsste für jede Zielmaschine geschrieben werden, aber nicht das gesamte Assemblerprogramm. Beachten Sie, dass leistungsfähigere Makro-Assembler die Verwendung von bedingten Assembler-Konstrukten in Makroanweisungen ermöglichten, die unterschiedlichen Code auf unterschiedlichen Maschinen oder unterschiedlichen Betriebssystemen generieren konnten, wodurch der Bedarf an mehreren Bibliotheken verringert wurde.[citation needed]

In den 1980er und frühen 1990er Jahren liefen Desktop-PCs nur mit wenigen MHz und Assembler-Routinen wurden häufig verwendet, um in C, Fortran, Pascal und anderen geschriebene Programme zu beschleunigen. Diese Sprachen verwendeten damals unterschiedliche Aufrufkonventionen. Makros könnten verwendet werden, um in Assembler geschriebene Routinen mit dem Frontend von Anwendungen zu verbinden, die in fast jeder Sprache geschrieben sind. Auch hier blieb der grundlegende Assemblersprachencode gleich, nur die Makrobibliotheken mussten für jede Zielsprache geschrieben werden.[citation needed]

In modernen Betriebssystemen wie Unix und seinen Derivaten wird der Zugriff auf das Betriebssystem durch Unterroutinen bereitgestellt, die normalerweise von dynamischen Bibliotheken bereitgestellt werden. Hochsprachen wie C bieten umfassenden Zugriff auf Betriebssystemfunktionen, wodurch Assembler-Sprachprogramme für diese Funktionalität überflüssig werden.[citation needed]

Siehe auch[edit]

Verweise[edit]

  1. ^ Oxford Englisch Wörterbuch, sv Makro, Makro-Anweisung, und Makro-
  2. ^ Greenwald, Irwin D.; Maureen Kane (April 1959). „Das Share 709-System: Programmierung und Modifikation“. Zeitschrift der ACM. New York, NY, USA: ACM. 6 (2): 128–133. mach:10.1145/320964.320967. S2CID 27424222. Eine der wichtigen Verwendungen von Programmiermakros besteht darin, Zeit und Schreibfehler beim Schreiben von Befehlsfolgen zu sparen, die im Verlauf eines Programms oft wiederholt werden.
  3. ^ Strachey, Christopher (Oktober 1965). "Ein Allzweck-Makrogenerator". Computerjournal. 8 (3): 225–241. mach:10.1093/comjnl/8.3.225.
  4. ^ "Runescape: The Massive Online Adventure Game von Jagex Ltd". Abgerufen 2008-04-03.
  5. ^ "Skripte: vim online". www.vim.org.
  6. ^ "Prolog-Makros". www.metalevel.at. Abgerufen 2021-04-05.
  7. ^ "Erlang - Präprozessor". erlang.org. Abgerufen 2021-05-24.
  8. ^ „Das Dylan-Makrosystem – Öffnen Sie Dylan“. opendylan.org. Abgerufen 2021-04-05.
  9. ^ "Def Makros". Scala-Dokumentation. Abgerufen 2021-04-05.
  10. ^ "Über - Offizielle Website der Programmiersprache Nemerle". nemerle.org. Abgerufen 2021-04-05.
  11. ^ "Makros - Die Programmiersprache Rust". doc.rust-lang.org. Abgerufen 2021-04-05.
  12. ^ "Makros". elixir-lang.github.com. Abgerufen 2021-04-05.
  13. ^ "Makros". nim-lang.org. Abgerufen 2021-04-05.
  14. ^ "Makros". Haxe - Das plattformübergreifende Toolkit.
  15. ^ "Metaprogrammierung · Die Julia-Sprache". docs.julialang.org. Abgerufen 2021-04-05.
  16. ^ "Sweet.js - Hygienische Makros für JavaScript". www.sweetjs.org.
  17. ^ "LeMP-Startseite · Verbessertes C#". ecsharp.net.
  18. ^ "Makros in Python: Quasiquotes, Fallklassen, LINQ und mehr!: lihaoyi/macropy". 7. Februar 2019 – über GitHub.
  19. ^ Marshall, Joe. "unbenannte E-Mail". Abgerufen 3. Mai, 2012.
  20. ^ „AIM-057, MACRO-Definitionen für LISP, Timothy P. Hart“. hdl:1721.1/6111.
  21. ^ Kohlbecker, Eugen; Friedmann, Daniel; Felleisen, Matthias; Duba, Bruce. "Hygienische Makro-Erweiterung". mach:10.1145/319838.319859.
  22. ^ [1] Clinger, Rees. "Makros, die funktionieren"
  23. ^ Flatt, Matthäus. "Zusammensetzbare und kompilierbare Makros: Wann wollen Sie es?" (PDF).
  24. ^ Rafkind, Jon; Flatt, Matthäus. "Honu: Syntaktische Erweiterung für algebraische Notation durch Enforestation" (PDF).
  25. ^ "Automaten über Makros". cs.brown.edu.
  26. ^ [2], Matthias Felleisen, LL1 Mailinglisten-Posting
  27. ^ Orgass, Richard J.; William M. Waite (September 1969). "Eine Basis für ein mobiles Programmiersystem". Mitteilungen des ACM. New York, NY, USA: ACM. 12 (9): 507–510. mach:10.1145/363219.363226. S2CID 8164996.
  28. ^ Waite, William M. (Juli 1970). "Das mobile Programmiersystem: STAGE2". Mitteilungen des ACM. New York, NY, USA: ACM. 13 (7): 415–421. mach:10.1145/362686.362691. S2CID 11733598.
  29. ^ "Universität von Nordflorida" (PDF).
  30. ^ "DTF (DOS/VSE)".
  31. ^ "IBM-Wissenscenter". IBM Knowledge Center.
  32. ^ ein B "Assembler-Sprachmakro-Anweisungen". Cisco.
  33. ^ ein B Holbrook, Bernard D.; Brown, W. Stanley. "Computing Science Technical Report Nr. 99 – Eine Geschichte der Computerforschung in Bell Laboratories (1937-1975)". Bell Labs. Archiviert von das Original am 2. September 2014. Abgerufen 2. Februar, 2020.
  34. ^ "Macro SAP – Makro-Compiler-Modifikation von SAP". HOPL: Historische Online-Enzyklopädie der Programmiersprachen. Archiviert von das Original am 13.08.2008.
  35. ^ Layzell, P. (1985). "Die Geschichte der Makroprozessoren in der Erweiterbarkeit von Programmiersprachen". Das Computerjournal. 28 (1): 29–33. mach:10.1093/comjnl/28.1.29.

Externe Links[edit]