Incomputer programming, amacro (short for "macro instruction"; from Greek μακρο- 'long, large'[1]) is a rule orpattern that specifies how a certain input should bemapped to a replacement output. Applying a macro to an input is known asmacro expansion.
The input and output may be a sequence oflexical tokens orcharacters, or asyntax tree. Character macros are supported insoftware applications to make it easy to invoke commoncommand sequences. Token and tree macros are supported in someprogramming languages to enablecode reuse or to extend the language, sometimes fordomain-specific languages.
Macros are used to make a sequence of computing instructions available to the programmer as a singleprogram statement, making the programming task less tedious and less error-prone.[2][3] Thus, they are called "macros" because a "big"block of code can be expanded from a "small" sequence of characters. Macros often allow positional or keyword parameters that dictate what theconditional assembler program generates and have been used to create entireprograms or program suites according to such variables asoperating system,platform or other factors. The term derives from "macro instruction", and such expansions were originally used in generatingassembly language code.
Keyboard macros andmouse macros allow short sequences of keystrokes and mouse actions to transform into other, usually more time-consuming, sequences of keystrokes and mouse actions. In this way, frequently used or repetitive sequences of keystrokes and mouse movements can beautomated. Separate programs for creating these macros are calledmacro recorders.
During the 1980s, macro programs – originallySmartKey, then SuperKey, KeyWorks, Prokey – were very popular, first as a means to automatically formatscreenplays, then for a variety of user-input tasks. These programs were based on theterminate-and-stay-resident mode of operation and applied to all keyboard input, no matter in which context it occurred. They have to some extent fallen into obsolescence following the advent of mouse-driven user interfaces and the availability of keyboard and mouse macros in applications, such asword processors andspreadsheets, making it possible to create application-sensitive keyboard macros.
Keyboard macros can be used inmassively multiplayer online role-playing games (MMORPGs) to perform repetitive, but lucrative tasks, thus accumulating resources. As this is done without human effort, it can skew the economy of the game. For this reason, use of macros is a violation of theTOS orEULA of most MMORPGs, and their administrators spend considerable effort to suppress them.[4]
Keyboard and mouse macros that are created using an application's built-in macro features are sometimes calledapplication macros. They are created by carrying out the sequence once and letting the application record the actions. An underlying macro programming language, most commonly ascripting language, with direct access to the features of the application may also exist.
The programmers' text editorEmacs (short for "editing macros") follows this idea to a conclusion. In effect, most of the editor is made of macros. Emacs was originally devised as a set of macros in the editing languageTECO; it was later ported to dialects ofLisp.
Another programmers' text editor,Vim (a descendant ofvi), also has an implementation of keyboard macros. It can record into a register (macro) what a person types on the keyboard and it can be replayed or edited just likeVBA macros for Microsoft Office. Vim also has a scripting language calledVimscript[5] to create macros.
Visual Basic for Applications (VBA) is a programming language included inMicrosoft Office from Office 97 through Office 2019 (although it was available in some components of Office prior to Office 97). However, its function has evolved from and replaced the macro languages that were originally included in some of these applications.
XEDIT, running on theConversational Monitor System (CMS) component ofVM, supports macros written inEXEC,EXEC2 andREXX, and some CMS commands were actually wrappers around XEDIT macros.The Hessling Editor (THE), a partial clone of XEDIT, supports Rexx macros using Regina and OpenObject REXX (oorexx). Many common applications, and some on PCs, use Rexx as a scripting language.
VBA has access to mostMicrosoft Windows system calls and executes when documents are opened. This makes it relatively easy to writecomputer viruses in VBA, commonly known asmacro viruses. In the mid-to-late 1990s, this became one of the most common types of computer virus. However, during the late 1990s and to date,Microsoft has been patching and updating its programs.[citation needed] In addition, current anti-virus programs immediately counteract such attacks.
Aparameterized macro is a macro that is able to insert given objects into its expansion. This gives the macro some of the power of afunction.
As a simple example, in theC programming language, this is a typical macro that isnot a parameterized macro, i.e., aparameterless macro:
#define PI 3.14159
This causesPI to always be replaced with3.14159 wherever it occurs. An example of a parameterized macro, on the other hand, is this:
#define pred(x) ((x)-1)
What this macro expands to depends on whatargumentx is passed to it. Here are some possible expansions:
pred(2) → ((2) -1) pred(y+2) → ((y+2) -1) pred(f(5)) → ((f(5))-1)
Parameterized macros are a useful source-level mechanism for performingin-line expansion, but in languages such asC where they use simple textual substitution, they have a number of severe disadvantages over other mechanisms for performing in-line expansion, such asinline functions.
The parameterized macros used in languages such asLisp,PL/I andScheme, on the other hand, are much more powerful, able to make decisions about what code to produce based on their arguments; thus, they can effectively be used to performrun-time code generation.
 | This sectiondoes notcite anysources. Please helpimprove this section byadding citations to reliable sources. Unsourced material may be challenged andremoved.(September 2024) (Learn how and when to remove this message) |
Languages such asC and someassembly languages have rudimentary macro systems, implemented aspreprocessors to the compiler or assembler.C preprocessor macros work by simple textual substitution at thetoken, rather than the character level. However, the macro facilities of more sophisticated assemblers, e.g.,IBM High Level Assembler (HLASM) can't be implemented with a preprocessor; the code for assembling instructions and data is interspersed with the code for assembling macro invocations.
A classic use of macros is in the computer typesetting systemTeX and its derivatives, where most functionality is based on macros.[6]
MacroML is an experimental system that seeks to reconcilestatic typing and macro systems.Nemerle has typed syntax macros, and one productive way to think of these syntax macros is as amulti-stage computation.
Other examples:
Some major applications have been written as text macro invoked by other applications, e.g., byXEDIT in CMS.
Some languages, such asPHP, can be embedded in free-format text, or the source code of other languages. The mechanism by which the code fragments are recognised (for instance, being bracketed by<?php and?>) is similar to a textual macro language, but they are much more powerful, fully featured languages.
| This sectiondoes notcite anysources. Please helpimprove this section byadding citations to reliable sources. Unsourced material may be challenged andremoved.(June 2014) (Learn how and when to remove this message) |
Macros in thePL/I language are written in a subset of PL/I itself: the compiler executes "preprocessor statements" at compilation time, and the output of this execution forms part of the code that is compiled. The ability to use a familiarprocedural language as the macro language gives power much greater than that of text substitution macros, at the expense of a larger and slower compiler. Macros in PL/I, as well as in many assemblers, may haveside effects, e.g., setting variables that other macros can access.
Frame technology's frame macros have their own command syntax but can also contain text in any language. Each frame is both a generic component in a hierarchy of nested subassemblies, and a procedure for integrating itself with its subassembly frames (a recursive process that resolves integration conflicts in favor of higher level subassemblies). The outputs are custom documents, typically compilable source modules. Frame technology can avoid the proliferation of similar but subtly different components, an issue that has plagued software development since the invention of macros andsubroutines.
Most assembly languages have less powerful procedural macro facilities, for example allowing a block of code to be repeated N times forloop unrolling; but these have a completely different syntax from the actual assembly language.
Macro systems—such as the C preprocessor described earlier—that work at the level of lexical tokens cannot preserve the lexical structure reliably.Syntactic macro systems work instead at the level ofabstract syntax trees, and preserve the lexical structure of the original program. The most widely used implementations of syntactic macro systems are found inLisp-like languages. These languages are especially suited for this style of macro due to their uniform, parenthesized syntax (known asS-expressions). In particular, uniform syntax makes it easier to determine the invocations of macros. Lisp macros transform the program structure itself, with the full language available to express such transformations. While syntactic macros are often found in Lisp-like languages, they are also available in other languages such asProlog,[7]Erlang,[8]Dylan,[9]Scala,[10]Nemerle,[11]Rust,[12]Elixir,[13]Nim,[14]Haxe,[15] andJulia.[16] They are also available as third-party extensions toJavaScript[17] andC#.[18]
Before Lisp had macros, it had so-calledFEXPRs, function-like operators whose inputs were not the values computed by the arguments but rather the syntactic forms of the arguments, and whose output were values to be used in the computation. In other words, FEXPRs were implemented at the same level as EVAL, and provided a window into the meta-evaluation layer. This was generally found to be a difficult model to reason about effectively.[19]
In 1963, Timothy Hart proposed adding macros to Lisp 1.5 inAI Memo 57: MACRO Definitions for LISP.[20]
An anaphoric macro is a type of programming macro that deliberately captures some form supplied to the macro which may be referred to by an anaphor (an expression referring to another). Anaphoric macros first appeared in Paul Graham's On Lisp and their name is a reference to linguistic anaphora—the use of words as a substitute for preceding words.
In the mid-eighties, a number of papers[21][22] introduced the notion ofhygienic macro expansion (syntax-rules), a pattern-based system where the syntactic environments of the macro definition and the macro use are distinct, allowing macro definers and users not to worry about inadvertent variable capture (cf.referential transparency). Hygienic macros have been standardized for Scheme in theR5RS,R6RS, andR7RS standards. A number of competing implementations of hygienic macros exist such assyntax-rules,syntax-case, explicit renaming, and syntactic closures. Bothsyntax-rules andsyntax-case have been standardized in the Scheme standards.
Recently,Racket has combined the notions of hygienic macros with a "tower of evaluators", so that the syntactic expansion time of one macro system is the ordinary runtime of another block of code,[23] and showed how to apply interleaved expansion and parsing in a non-parenthesized language.[24]
A number of languages other than Scheme either implement hygienic macros or implement partially hygienic systems. Examples includeScala,Rust,Elixir,Julia,Dylan,Nim, andNemerle.
cond but lacksif, it is possible to define the latter in terms of the former using macros. For example, Scheme has bothcontinuations and hygienic macros, which enables a programmer to design their own control abstractions, such as looping and early exit constructs, without the need to build them into the language.let into the application of a function to a set of arguments.Felleisen conjectures[26] that these three categories make up the primary legitimate uses of macros in such a system. Others have proposed alternative uses of macros, such asanaphoric macros in macro systems that are unhygienic or allow selective unhygienic transformation.
The interaction of macros and other language features has been a productive area of research. For example,components andmodules are useful for large-scale programming, but the interaction of macros and these other constructs must be defined for their use together. Module and component-systems that can interact with macros have been proposed for Scheme and other languages with macros. For example, theRacket language extends the notion of a macro system to a syntactic tower, where macros can be written in languages including macros, using hygiene to ensure that syntactic layers are distinct and allowing modules to export macros to other modules.
Macros are normally used to map a short string (macro invocation) to a longer sequence of instructions. Another, less common, use of macros is to do the reverse: to map a sequence of instructions to a macro string. This was the approach taken by theSTAGE2 Mobile Programming System, which used a rudimentary macro compiler (called SIMCMP) to map the specific instruction set of a given computer intomachine-independent macros. Applications (notably compilers) written in these machine-independent macros can then be run without change on any computer equipped with the rudimentary macro compiler. The first application run in such a context is a more sophisticated and powerful macro compiler, written in the machine-independent macro language. This macro compiler is applied to itself, in abootstrap fashion, to produce a compiled and much more efficient version of itself. The advantage of this approach is that complex applications can be ported from one computer to a very different computer with very little effort (for each target machine architecture, just the writing of the rudimentary macro compiler).[27][28] The advent of modern programming languages, notablyC, for which compilers are available on virtually all computers, has rendered such an approach superfluous. This was, however, one of the first instances (if not the first) ofcompiler bootstrapping.
Whilemacro instructions can be defined by a programmer for any set of native assembler program instructions, typically macros are associated with macro libraries delivered with the operating system allowing access to operating system functions such as
In older operating systems such as those used on IBM mainframes, full operating system functionality was only available to assembler language programs, not to high level language programs (unless assembly language subroutines were used, of course), as the standard macro instructions did not always have counterparts in routines available to high-level languages.
In the mid-1950s, whenassembly language programming was the main way to program acomputer,macro instructionfeatures were developed to reduce source code (by generating multiple assembly statements from each macro instruction) and to enforce coding conventions (e.g. specifying input/output commands in standard ways).[31] A macro instruction embedded in the otherwise assembly source code would be processed by a macro compiler, apreprocessor to the assembler, to replace the macro with one or more assembly instructions. The resulting code, pure assembly, would be translated tomachine code by the assembler.[32]
Two of the earliest programming installations to develop macro languages for the IBM 705 computer were at Dow Chemical Corp. in Delaware and the Air Material Command, Ballistics Missile Logistics Office in California.
Some consider macro instructions as an intermediate step between assembly language programming and thehigh-level programming languages that followed, such asFORTRAN andCOBOL.
By the late 1950s the macro language was followed by theMacro Assemblers. This was a combination of both where one program served both functions, that of a macro pre-processor and an assembler in the same package.[32][failed verification] Early examples areFORTRAN Assembly Program (FAP)[33] and Macro Assembly Program (IBMAP)[34] on theIBM 709,7094,7040 and 7044, andAutocoder[35] on the7070/7072/7074.
In 1959, Douglas E. Eastwood andDouglas McIlroy ofBell Labs introduced conditional and recursive macros into the popularSAP assembler,[36] creating what is known as Macro SAP.[37] McIlroy's 1960 paper was seminal in the area of extending any (includinghigh-level) programming languages throughmacro processors.[38][36]
Macro Assemblers allowed assembly language programmers to implement their own macro-language and allowed limited portability of code between two machines running the same CPU but different operating systems, for example, early versions ofMS-DOS andCP/M-86. The macro library would need to be written for each target machine but not the overall assembly language program. Note that more powerful macro assemblers allowed use of conditional assembly constructs in macro instructions that could generate different code on different machines or different operating systems, reducing the need for multiple libraries.[citation needed]
In the 1980s and early 1990s, desktop PCs were only running at a few MHz and assembly language routines were commonly used to speed up programs written in C, Fortran, Pascal and others. These languages, at the time, used different calling conventions. Macros could be used to interface routines written in assembly language to the front end of applications written in almost any language. Again, the basic assembly language code remained the same, only the macro libraries needed to be written for each target language.[citation needed]
In modern operating systems such as Unix and its derivatives, operating system access is provided through subroutines, usually provided by dynamic libraries. High-level languages such as C offer comprehensive access to operating system functions, obviating the need for assembler language programs for such functionality.[citation needed]
Moreover,standard libraries of several newer programming languages, such asGo, actively discourage the use ofsyscalls in favor ofplatform-agnostic libraries as well if not necessary, to improveportability and security.[39]
One of the important uses of programmer macros is to save time and clerical-type errors in writing sequence of instructions which are often repeated in the course of a program.
TEX has a macro programming language, which allows features to be added.
| International | |
|---|---|
| National | |
| Other | |
