You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 18.208.0.0/16 has been blocked (disabled) by ‪ST47‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider. To prevent abuse, web hosts may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a web host's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and they should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 01:01, 24 April 2026.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis. The block was made by ‪AntiCompositeNumber‬. The reason given is Open proxy/Webhost: See the help page if you are affected .
- Start of block: 15:08, 30 August 2023
- Expiry of block: 15:08, 30 August 2025
Your current IP address is 18.208.109.86. The blocked range is 18.208.0.0/16. Please include all above details in any queries you make. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

You can view and copy the source of this page:

((Short description|Rule for substituting a set input with a set output))
((Redirect|Macro language|ISO macrolanguages|ISO 639 macrolanguage))
[[File:Jedit macro recorder.png|thumb|250px|[[jEdit|jEdit's]] macro editor]]
In [[computer programming]], a '''macro''' (short for "'''macro instruction'''"; ((ety|el|''μακρο''-|long, large))<ref>''[[Oxford English Dictionary]]'', ''s.v.'' [https://www.oed.com/view/Entry/111926 macro], [https://www.oed.com/view/Entry/233194 macro-instruction], and [https://www.oed.com/view/Entry/111927 macro-]</ref>) is a rule or [[pattern]] that specifies how a certain input should be [[Map (mathematics)|mapped]] to a replacement output. Applying a macro to an input is known as '''macro expansion'''. The input and output may be a sequence of [[lexical token]]s or [[Character (computing)|characters]], or a [[abstract syntax tree|syntax tree]]. Character macros are supported in [[software application]]s to make it easy to invoke common [[Command (computing)|command]] sequences. Token and tree macros are supported in some [[programming language]]s to enable [[code reuse]] or to extend the language, sometimes for [[domain-specific languages]].

Macros are used to make a sequence of computing instructions available to the programmer as a single [[program statement]], making the programming task less tedious and less error-prone.<ref>((cite journal | last = Greenwald | first = Irwin D. |author2=Maureen Kane | title = The Share 709 System: Programming and Modification | journal = Journal of the ACM | volume = 6 | issue = 2  | pages = 128–133 | publisher = ACM | location = New York, NY, USA | date = April 1959 | doi = 10.1145/320964.320967 | s2cid = 27424222 | quote= 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.| doi-access = free ))</ref><ref>((cite journal | last = Strachey| first = Christopher | title = A General Purpose Macrogenerator| journal = Computer Journal| volume = 8 | issue = 3 | pages = 225–241|date=October 1965 | doi = 10.1093/comjnl/8.3.225 |author-link=Christopher Strachey| doi-access = free))</ref> Thus, they are called "macros" because a "big" [[Block (programming)|block of code]] can be expanded from a "small" sequence of characters. Macros often allow positional or keyword parameters that dictate what the [[Conditional assembly language|conditional assembler]] program generates and have been used to create entire [[Computer program|programs]] or program suites according to such variables as [[operating system]], [[Computing platform|platform]] or other factors. The term derives from "macro instruction", and such expansions were originally used in generating [[assembly language]] code.

==Keyboard and mouse macros==
'''Keyboard macros''' and '''mouse 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 be [[automate]]d. Separate programs for creating these macros are called [[macro recorder]]s.

During the 1980s, macro programs&nbsp;– originally [[SmartKey]], then SuperKey, KeyWorks, Prokey&nbsp;– were very popular, first as a means to automatically format [[screenplay]]s, then for a variety of user input tasks. These programs were based on the [[terminate-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 as [[word processor]]s and [[spreadsheet]]s, making it possible to create application-sensitive keyboard macros.

Keyboard macros can be used in [[massively multiplayer online role-playing game]]s (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 the [[Terms of Service|TOS]] or [[EULA]] of most MMORPGs, and their administrators spend considerable effort to suppress them.<ref>((cite web |url=http://www.runescape.com/ |title=Runescape: The Massive Online Adventure Game by Jagex Ltd. |access-date=2008-04-03))</ref>

===Application macros and scripting===
Keyboard and mouse macros that are created using an application's built-in macro features are sometimes called '''application macros'''. They are created by carrying out the sequence once and letting the application record the actions. An underlying macro programming language, most commonly a [[scripting language]], with direct access to the features of the application may also exist.

The programmers' text editor, [[Emacs]], (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 language [[Text Editor and Corrector|TECO]]; it was later ported to dialects of [[Lisp (programming language)|Lisp]].

Another programmers' text editor, [[Vim (text editor)|Vim]] (a descendant of [[Vi (text editor)|vi]]), 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 like [[Visual Basic for Applications|VBA]] macros for Microsoft Office. Vim also has a scripting language called [[Vimscript]]<ref>((cite web|url=https://www.vim.org/scripts/index.php|title=scripts: vim online|website=www.vim.org))</ref> to create macros.

[[Visual Basic for Applications]] (VBA) is a programming language included in [[Microsoft 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 the [[Conversational Monitor System]] (CMS) component of [[VM (operating system)|VM]], supports macros written in [[CMS EXEC|EXEC]], [[EXEC2]] and [[REXX]], 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 Open [[Object REXX]] (oorexx). Many common applications, and some on PCs, use Rexx as a scripting language.

====Macro virus====
((Main article|Macro virus (computing)))
[[Visual Basic for Applications|VBA]] has access to most [[Win32 API|Microsoft Windows system call]]s and executes when documents are opened. This makes it relatively easy to write [[computer virus]]es in VBA, commonly known as [[Macro virus (computing)|macro virus]]es. 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.((cn|date=April 2022)) In addition, current anti-virus programs immediately counteract such attacks.

==Parameterized and parameterless macro((anchor|Parameterized macro|Parameterized|Parameterless))==

A '''parameterized macro''' is a macro that is able to insert given objects into its expansion. This gives the macro some of the power of a [[function (computer science)|function]].

As a simple example, in the [[C (programming language)|C programming language]], this is a typical macro that is ''not'' a parameterized macro, i.e., a '''parameterless macro''':
  '''#define''' PI   3.14159
This causes <code>PI</code> to always be replaced with <code>3.14159</code> 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 what [[argument (computer science)|argument]] ''x'' 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 performing [[inline expansion|in-line expansion]], but in languages such as [[C (programming language)|C]] where they use simple textual substitution, they have a number of severe disadvantages over other mechanisms for performing in-line expansion, such as [[inline function]]s.

The parameterized macros used in languages such as [[Lisp programming language|Lisp]], [[PL/I]] and [[Scheme (programming language)|Scheme]], 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 perform [[run-time code generation]].

==Text-substitution macros==
((See also|General-purpose macro processor|Assembly language#Macros|Algorithm))
Languages such as [[C (programming language) |C]] and some [[assembly language]]s have rudimentary macro systems, implemented as [[preprocessor]]s to the compiler or assembler. [[C preprocessor]] macros work by simple textual substitution at the [[Lexical token|token]], 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 system [[TeX]] and its derivatives, where most of the functionality is based on macros.

[[MacroML]] is an experimental system that seeks to reconcile [[static typing]] and macro systems. [[Nemerle]] has typed syntax macros, and one productive way to think of these syntax macros is as a [[Metaprogramming|multi-stage computation]].

Other examples:
* [[m4 (computer language)|m4]] is a sophisticated stand-alone macro processor.
* [[TRAC programming language|TRAC]]
* [[METAL|Macro Extension TAL]], accompanying [[Template Attribute Language]]
* SMX: for web pages
* [[ML/I|ML/1]] (Macro Language One)
* The [[General Purpose Macrogenerator]] is a contextual pattern-matching macro processor, which could be described as a combination of [[regular expression]]s, [[EBNF]] and [[AWK]]((citation needed|date=February 2020))
* [[troff]] and [[nroff]]: for typesetting and formatting Unix manpages.
* [[CMS EXEC]]: for command-line macros and application macros
* [[EXEC 2]] in [[Conversational Monitor System]] (CMS): for command-line macros and application macros
* [[CLIST]] in IBM's [[Time Sharing Option]] (TSO): for command-line macros and application macros
* [[REXX]]: for command-line macros and application macros in, e.g., [[AmigaOS]], CMS, [[OS/2]], TSO
* [[SCRIPT (markup)#SCRIPT macros|SCRIPT]]: for formatting documents
* Various [[Shell (computing)#Text (CLI) shells|shells]] for, e.g., [[Linux]]

Some major applications have been written as text macro invoked by other applications, e.g., by [[XEDIT]] in CMS.

===Embeddable languages===
Some languages, such as [[PHP]], 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 <code><?php</code> and <code>?></code>) is similar to a textual macro language, but they are much more powerful, fully featured languages.

==Procedural macros==
((unreferenced section|date=June 2014))
Macros in the [[PL/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 familiar [[procedural 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 have [[side effect (computer science)|side effect]]s, e.g., setting variables that other macros can access.

[[Frame technology (software engineering)|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 and [[subroutine]]s.

Most assembly languages have less powerful procedural macro facilities, for example allowing a block of code to be repeated N times for [[loop unwinding|loop unrolling]]; but these have a completely different syntax from the actual assembly language.

== Syntactic macros ==
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 of [[abstract syntax tree]]s, and preserve the lexical structure of the original program. The most widely used implementations of syntactic macro systems are found in [[Lisp (programming language)|Lisp]]-like languages. These languages are especially suited for this style of macro due to their uniform, parenthesized syntax (known as [[S-expression]]s). 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 as [[Prolog]],<ref>((Cite web|title=Prolog Macros|url=https://www.metalevel.at/prolog/macros|access-date=2021-04-05|website=www.metalevel.at))</ref> [[Erlang (programming language)|Erlang]],<ref>((Cite web|title=Erlang -- Preprocessor|url=https://erlang.org/doc/reference_manual/macros.html#defining-and-using-macros|access-date=2021-05-24|website=erlang.org))</ref> [[Dylan (programming language)|Dylan]],<ref>((Cite web|title=The Dylan Macro System — Open Dylan|url=https://opendylan.org/articles/macro-system/index.html|access-date=2021-04-05|website=opendylan.org))</ref> [[Scala (programming language)|Scala]],<ref>((Cite web|title=Def Macros|url=https://docs.scala-lang.org/overviews/macros/overview.html|access-date=2021-04-05|website=Scala Documentation))</ref> [[Nemerle]],<ref>((Cite web|title=About - Nemerle programming language official site|url=http://nemerle.org/About|access-date=2021-04-05|website=nemerle.org))</ref> [[Rust (programming language)|Rust]],<ref>((Cite web|title=Macros - The Rust Programming Language|url=https://doc.rust-lang.org/book/ch19-06-macros.html|access-date=2021-04-05|website=doc.rust-lang.org))</ref> [[Elixir (programming language)|Elixir]],<ref>((Cite web|title=Macros|url=https://elixir-lang.org/getting-started/meta/macros.html|access-date=2021-04-05|website=elixir-lang.github.com|language=en))</ref> [[Nim (programming language)|Nim]],<ref>((Cite web|title=macros|url=https://nim-lang.org/docs/macros.html|access-date=2021-04-05|website=nim-lang.org))</ref> [[Haxe]],<ref>((cite web|url=https://haxe.org/manual/macro.html|title=Macros|website=Haxe - The Cross-platform Toolkit))</ref> and [[Julia (programming language)|Julia]].<ref>((Cite web|title=Metaprogramming · The Julia Language|url=https://docs.julialang.org/en/v1/manual/metaprogramming/#man-macros|access-date=2021-04-05|website=docs.julialang.org))</ref> They are also available as third-party extensions to [[JavaScript]]<ref>((cite web|url=https://www.sweetjs.org/|title=Sweet.js - Hygienic Macros for JavaScript|website=www.sweetjs.org))</ref> and [[C Sharp (programming language)|C#]].<ref>((cite web|url=http://ecsharp.net/lemp/|title=LeMP Home Page · Enhanced C#|website=ecsharp.net))</ref>

=== Early Lisp macros ===
Before Lisp had macros, it had so-called [[Fexpr|FEXPRs]], 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.<ref>((cite web|last=Marshall|first=Joe|title=untitled email|url=http://www.brinckerhoff.org/scraps/joe-marshall-on-FEXPRS-and-DEFMACRO.txt|access-date=May 3, 2012))</ref>

In 1963, Timothy Hart proposed adding macros to Lisp 1.5 in [[AI Memo]] 57: MACRO Definitions for LISP.<ref>((cite periodical |id=AIM-057 |title=MACRO Definitions for LISP |periodical=AI Memos |date=October 1963|hdl=1721.1/6111 |hdl-access=free |last1=Hart|first1=Timothy P.))</ref>

=== Anaphoric macros ===
((Main article|Anaphoric macro))
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.

=== Hygienic macros ===
((Main article|Hygienic macro))

In the mid-eighties, a number of papers<ref>((cite conference |last1=Kohlbecker |first1=Eugene |last2=Friedman |first2=Daniel |last3=Felleisen |first3=Matthias |last4=Duba |first4=Bruce |book-title=LFP '86: Proceedings of the 1986 ACM conference on LISP and functional programming |title=Hygienic Macro Expansion |year=1986 |pages=151–161 |doi=10.1145/319838.319859 |isbn=0897912004))</ref><ref>[http://portal.acm.org/citation.cfm?id=99583.99607] Clinger, Rees. "Macros that Work"</ref> introduced the notion of [[hygienic macro]] expansion (<CODE>syntax-rules</CODE>), 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 the [[R5RS]], [[R6RS]], and [[R7RS]] standards. A number of competing implementations of hygienic macros exist such as <code>syntax-rules</code>, <code>syntax-case</code>, explicit renaming, and syntactic closures. Both <code>syntax-rules</code> and <code>syntax-case</code> have been standardized in the Scheme standards.

Recently, [[Racket (programming language)|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,<ref>((cite news | last1 = Flatt | first1 = Matthew | title = Composable and compilable macros: you want it when? |url=http://www.cs.utah.edu/plt/publications/macromod.pdf))</ref> and showed how to apply interleaved expansion and parsing in a non-parenthesized language.<ref>((cite news | last1 = Rafkind | first1 = Jon | last2 = Flatt | first2 = Matthew | title = Honu: Syntactic Extension for Algebraic Notation through Enforestation |url=http://www.cs.utah.edu/plt/publications/gpce12-rf.pdf))</ref>

A number of languages other than Scheme either implement hygienic macros or implement partially hygienic systems. Examples include [[Scala (programming language)|Scala]], [[Rust (programming language)|Rust]], [[Elixir (programming language)|Elixir]], [[Julia (programming language)|Julia]], [[Dylan (programming language)|Dylan]], [[Nim (programming language)|Nim]], and [[Nemerle]].

=== Applications ===
; Evaluation order
:Macro systems have a range of uses. Being able to choose the order of evaluation (see [[lazy evaluation]] and [[Strict function|non-strict functions]]) enables the creation of new syntactic constructs (e.g. [[control structures]]) indistinguishable from those built into the language. For instance, in a Lisp dialect that has <CODE>cond</CODE> but lacks <CODE>if</CODE>, it is possible to define the latter in terms of the former using macros. For example, Scheme has both [[continuation]]s 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.
; Data sub-languages and domain-specific languages
: Next, macros make it possible to define data languages that are immediately compiled into code, which means that constructs such as [[state machine]]s can be implemented in a way that is both natural and efficient.<ref>((cite web|url=http://cs.brown.edu/~sk/Publications/Papers/Published/sk-automata-macros/|title=Automata via Macros|website=cs.brown.edu))</ref>
; Binding constructs
:Macros can also be used to introduce new binding constructs. The most well-known example is the transformation of <CODE>let</CODE> into the application of a function to a set of arguments.

[[Matthias Felleisen|Felleisen]] conjectures<ref name="three-uses">[http://people.csail.mit.edu/gregs/ll1-discuss-archive-html/msg01539.html], Matthias Felleisen, LL1 mailing list posting</ref> that these three categories make up the primary legitimate uses of macros in such a system. Others have proposed alternative uses of macros, such as [[anaphoric macro]]s 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, [[Software component|component]]s and [[Modular programming|module]]s 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, the [[Racket (programming language)|Racket]] 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 for machine-independent software==
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 the [[STAGE2|STAGE2 Mobile Programming System]], which used a rudimentary macro compiler (called SIMCMP) to map the specific instruction set of a given computer into ''machine-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 a [[Bootstrapping (computing)|bootstrap]] 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).<ref>((cite journal
 | last = Orgass | first = Richard J. |author2=William M. Waite | title = A base for a mobile programming system | journal = Communications of the ACM | volume = 12 | issue = 9 | pages = 507–510 | publisher = ACM | location = New York, NY, USA | date = September 1969 | doi = 10.1145/363219.363226
| s2cid = 8164996 | doi-access = free ))</ref><ref>((cite journal | last = Waite | first = William M. | title = The mobile programming system: STAGE2 | journal = Communications of the ACM | volume = 13 | issue = 7 | pages = 415–421 | publisher = ACM | location = New York, NY, USA | date = July 1970 | doi = 10.1145/362686.362691
| s2cid = 11733598 ))</ref> The advent of modern programming languages, notably [[C (programming language)|C]], 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) of [[Bootstrapping (compilers)|compiler bootstrapping]].

==Assembly language==
While ''macro 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
* peripheral access by [[access methods]] (including macros such as OPEN, CLOSE, READ and WRITE) 
* operating system functions such as ATTACH, WAIT and POST for subtask creation and synchronization.<ref>((cite web|title=University of North Florida|url=https://www.unf.edu/~cwinton/html/cop3601/s10/class.notes/asm6-Macros.pdf))</ref> Typically such macros expand into executable code, e.g., for the EXIT macroinstruction, 
* a list of ''define constant'' instructions, e.g., for the [[Data Control Block|DCB]] macro—DTF (Define The File) for [[DOS/360 and successors|DOS]]<ref>((cite web
|url=https://www.ibm.com/support/knowledgecenter?origURL=api/redirect/zvm/v5r4/index.jsp |title=DTF (DOS/VSE)|website=[[IBM]] ))</ref>—or a combination of code and constants, with the details of the expansion depending on the parameters of the macro instruction (such as a reference to a file and a data area for a READ instruction); 
* the executable code often terminated in either a ''branch and link register'' instruction to call a routine, or a [[supervisor call]] instruction to call an operating system function directly.
* Generating a ''Stage 2'' job stream for [[System Generation (OS)|system generation]] in, e.g., [[OS/360]]. Unlike typical macros, sysgen stage 1 macros do not generate data or code to be loaded into storage, but rather use the '''PUNCH''' statement to output JCL and associated data.

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.

==History==
In the mid-1950s, when [[assembly language]] programming was commonly used to write programs for [[digital computer]]s, the use of '''macro instructions''' was initiated for two main purposes: to reduce the amount of program coding that had to be written by generating several assembly language statements from one macro instruction and to enforce program writing standards, e.g. specifying input/output commands in standard ways.<ref>((cite web|title=IBM Knowledge Center|url=http://www.ibm.com/support/knowledgecenter/SSLTBW_2.1.0/com.ibm.zos.v2r1.asma400/asmr102115.htm|website=IBM Knowledge Center|date=16 August 2013))</ref> Macro instructions were effectively a middle step between assembly language programming and the [[high-level programming languages]] that followed, such as [[FORTRAN]] and [[COBOL]]. 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. A macro instruction written in the format of the target assembly language would be processed by a macro compiler, which was a pre-processor to the assembler, to generate one or more assembly language instructions to be processed next by the assembler program that would translate the assembly language instructions into [[machine language]] instructions.<ref name=cisco>((cite web|title=Assembler Language Macro Instructions|url=http://www.cisco.com/c/en/us/td/docs/ios/sw_upgrades/interlink/r2_0/api_ref/ammac.html#wp1686|website=Cisco))</ref>

By the late 1950s the macro language was followed by the [[Macro Assembler]]s. 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.<ref name=cisco/>((Failed verification|date=February 2020))

In 1959, Douglas E. Eastwood and [[Douglas McIlroy]] of [[Bell Labs]] introduced conditional and recursive macros into the popular [[Symbolic Assembly Program|SAP]] assembler,<ref name="CSTR99">((cite web |url=http://cm.bell-labs.com/cm/cs/cstr/99.html |archive-url=https://archive.today/20140902215751/http://cm.bell-labs.com/cm/cs/cstr/99.html |archive-date=September 2, 2014 |title=Computing Science Technical Report No. 99 – A History of Computing Research at Bell Laboratories (1937–1975) |first1=Bernard D. |last1=Holbrook |first2=W. Stanley |last2=Brown |publisher=[[Bell Labs]] |access-date=February 2, 2020))</ref> creating what is known as Macro SAP.<ref name="MSAP">((cite encyclopedia |title=Macro SAP – Macro compiler modification of SAP |encyclopedia=HOPL: Online Historical Encyclopaedia of Programming Languages |url=http://hopl.murdoch.edu.au/showlanguage.prx?exp=91 |archive-url=https://web.archive.org/web/20080813125120/http://hopl.murdoch.edu.au/showlanguage.prx?exp=91 |archive-date=August 13, 2008))</ref> McIlroy's 1960 paper was seminal in the area of extending any (including [[high-level programming language|high-level]]) programming languages through [[general-purpose macro processor|macro processors]].<ref name="Lay85">((cite journal |last=Layzell |first=P. |author-link=Paul Layzell |year=1985 |title=The History of Macro Processors in Programming Language Extensibility |journal=The Computer Journal |volume=28 |issue=1 |pages=29–33|doi=10.1093/comjnl/28.1.29 |doi-access=free ))</ref><ref name="CSTR99"/>

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 of [[MS-DOS]] and [[CP/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|date=February 2020))

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|date=February 2020))

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|date=February 2020))

==See also==
* ((annotated link|Anaphoric macro))s
* ((section link|Assembly language|Macros)) (the origin of the concept of macros)
* [[Compound operator]]
* ((annotated link|Extensible programming))
* [[Fused operation]]
* ((annotated link|Hygienic macro))s
* [[Macro and security]]
* ((annotated link|Programming by demonstration))
* ((annotated link|String interpolation))

==References==
((reflist))

==External links==
* [http://www.ibm.com/support/knowledgecenter/SSLTBW_2.1.0/com.ibm.zos.v2r1.asma400/macifmt.htm  How to write Macro Instructions]
*[http://meseec.ce.rit.edu/eecc250-winter99/250-2-2-2000.pdf  Rochester Institute of Technology, Professors Powerpoint]

((Programming paradigms navbox))
((Types of programming languages))

((Authority control))

[[Category:Programming constructs]]
[[Category:Source code]]
[[Category:Automation software]]

Pages transcluded onto the current version of this page (help):

Anaphoric macro (edit)
Extensible programming (edit)
Hygienic macro (edit)
Macro (computer science) (edit)
Macro language (edit)
Programming by demonstration (edit)
String interpolation (edit)
Template:Ambox (view source) (template editor protected)
Template:Anchor (view source) (template editor protected)
Template:Annotated link (view source) (template editor protected)
Template:Authority control (view source) (template editor protected)
Template:Category handler (view source) (protected)
Template:Citation needed (view source) (protected)
Template:Cite conference (view source) (protected)
Template:Cite encyclopedia (view source) (protected)
Template:Cite journal (view source) (protected)
Template:Cite magazine (view source) (protected)
Template:Cite news (view source) (protected)
Template:Cite periodical (view source) (semi-protected)
Template:Cite web (view source) (protected)
Template:Cn (view source) (template editor protected)
Template:Delink (view source) (protected)
Template:Ety (view source) (template editor protected)
Template:Etymology (view source) (semi-protected)
Template:Etymology/lang (view source) (semi-protected)
Template:Failed verification (view source) (template editor protected)
Template:Fix (view source) (protected)
Template:Fix/category (view source) (protected)
Template:Hlist/styles.css (view source) (protected)
Template:ISO 639 name (view source) (template editor protected)
Template:Main (view source) (template editor protected)
Template:Main article (view source) (template editor protected)
Template:Main other (view source) (protected)
Template:Navbox (view source) (template editor protected)
Template:Pagetype (view source) (protected)
Template:Programming paradigms navbox (edit)
Template:Redirect (view source) (template editor protected)
Template:Reflist (view source) (protected)
Template:Reflist/styles.css (view source) (protected)
Template:SDcat (view source) (protected)
Template:Section link (view source) (template editor protected)
Template:See also (view source) (template editor protected)
Template:Short description (view source) (protected)
Template:Short description/lowercasecheck (view source) (protected)
Template:Types of programming languages (edit)
Template:Unreferenced (view source) (template editor protected)
Template:Unreferenced section (view source) (template editor protected)
Module:Anchor (view source) (template editor protected)
Module:Annotated link (view source) (template editor protected)
Module:Arguments (view source) (protected)
Module:Authority control (view source) (template editor protected)
Module:Authority control/config (view source) (template editor protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:Delink (view source) (protected)
Module:Disambiguation/templates (view source) (protected)
Module:EditAtWikidata (view source) (protected)
Module:Format link (view source) (template editor protected)
Module:GetShortDescription (view source) (template editor protected)
Module:Hatnote (view source) (template editor protected)
Module:Hatnote/styles.css (view source) (template editor protected)
Module:Hatnote list (view source) (template editor protected)
Module:ISO 639 name (view source) (template editor protected)
Module:Labelled list hatnote (view source) (template editor protected)
Module:Lang (view source) (template editor protected)
Module:Lang/ISO 639 synonyms (view source) (template editor protected)
Module:Lang/data (view source) (template editor protected)
Module:Language/data/ISO 639-3 (dep) (view source) (template editor protected)
Module:Language/data/ISO 639 deprecated (view source) (template editor protected)
Module:Language/data/ISO 639 override (view source) (template editor protected)
Module:Language/data/iana languages (view source) (template editor protected)
Module:Language/data/iana regions (view source) (template editor protected)
Module:Language/data/iana scripts (view source) (template editor protected)
Module:Language/data/iana suppressed scripts (view source) (template editor protected)
Module:Language/data/iana variants (view source) (template editor protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Navbar (view source) (protected)
Module:Navbar/configuration (view source) (protected)
Module:Navbar/styles.css (view source) (protected)
Module:Navbox (view source) (template editor protected)
Module:Navbox/configuration (view source) (template editor protected)
Module:Navbox/styles.css (view source) (template editor protected)
Module:Pagetype (view source) (protected)
Module:Pagetype/config (view source) (protected)
Module:Pagetype/disambiguation (view source) (protected)
Module:Pagetype/setindex (view source) (protected)
Module:Pagetype/softredirect (view source) (protected)
Module:Redirect hatnote (view source) (template editor protected)
Module:SDcat (view source) (protected)
Module:Section link (view source) (template editor protected)
Module:String (view source) (protected)
Module:TableTools (view source) (protected)
Module:Unicode data (view source) (template editor protected)
Module:Unsubst (view source) (protected)
Module:Wikitext Parsing (view source) (protected)
Module:Yesno (view source) (protected)

Return to Macro (computer science).

Retrieved from "https://en.wikipedia.org/wiki/Macro_(computer_science)"