Macro (ciência da computação)

Da Wikipédia, a enciclopédia livre
Ir para a navegação Saltar para pesquisar
editor de macro do jEdit

Uma macro (abreviação de "instrução de macro", da forma grega de combinação μακρο- "longo, grande" [1] ) em ciência da computação é uma regra ou padrão que especifica como uma determinada entrada deve ser mapeada para uma saída de substituição. Aplicar uma macro a uma entrada é uma expansão de macro . A entrada e a saída podem ser uma seqüência de tokens ou caracteres lexicais , ou uma árvore sintática . As macros de caracteres são suportadas em aplicativos de software para facilitar a chamada de sequências de comandos comuns. As macros de token e de árvore são suportadas em algumas linguagens de programação para permitirreutilização de código ou para estender o idioma, às vezes para idiomas específicos de domínio .

As macros são usadas para disponibilizar uma sequência de instruções de computação ao programador como uma única instrução de programa, tornando a tarefa de programação menos tediosa e menos propensa a erros. [2] [3] (Assim, eles são chamados de "macros" porque um "grande" bloco de código pode ser expandido a partir de uma "pequena" seqüência de caracteres ) . gera e foi usado para criar programas inteiros ou suítes de programas de acordo com variáveis ​​como sistema operacional , plataforma ou outros fatores. O termo deriva de "instrução macro", e tais expansões foram originalmente usadas para gerarcódigo em linguagem assembly .

Macros de teclado e mouse

Macros de teclado e macros de mouse permitem que sequências curtas de pressionamentos de tecla e ações do mouse se transformem em outras, geralmente mais demoradas, sequências de pressionamentos de tecla e ações do mouse. Dessa forma, sequências de teclas e movimentos do mouse usadas com frequência ou repetitivas podem ser automatizadas . Programas separados para criar essas macros são chamados de gravadores de macros .

Durante a década de 1980, os programas de macro – originalmente SmartKey , depois SuperKey, KeyWorks, Prokey – eram muito populares, primeiro como um meio de formatar automaticamente roteiros , depois para uma variedade de tarefas de entrada do usuário. Esses programas eram baseados no modo de operação TSR ( terminar e permanecer residente ) e aplicados a todas as entradas do teclado, independentemente do contexto em que ocorressem. Eles caíram em certa medida em obsolescência após o advento de interfaces de usuário orientadas por mouse e a disponibilidade de macros de teclado e mouse em aplicativos como processadores de texto e planilhas , tornando possível criar macros de teclado sensíveis a aplicativos.

As macros de teclado podem ser usadas em jogos de RPG online multijogador massivo (MMORPGs) para realizar tarefas repetitivas, mas lucrativas, acumulando recursos. Como isso é feito sem esforço humano, pode distorcer a economia do jogo. Por esta razão, o uso de macros é uma violação do TOS ou EULA da maioria dos MMORPGs, e seus administradores gastam um esforço considerável para suprimi-los. [4]

Macros de aplicativos e scripts

As macros de teclado e mouse criadas usando os recursos de macro integrados de um aplicativo às vezes são chamadas de macros de aplicativo . Eles são criados executando a sequência uma vez e deixando o aplicativo registrar as ações. Uma linguagem de programação de macro subjacente, mais comumente uma linguagem de script , com acesso direto aos recursos do aplicativo também pode existir.

O editor de texto dos programadores, Emacs , (abreviação de "edição de macros") segue essa ideia até o fim. Na verdade, a maior parte do editor é feita de macros. O Emacs foi originalmente concebido como um conjunto de macros na linguagem de edição TECO ; foi posteriormente portado para dialetos de Lisp .

Outro editor de texto dos programadores, o Vim (descendente do vi ), também possui uma implementação de macros de teclado. Ele pode gravar em um registro (macro) o que uma pessoa digita no teclado e pode ser reproduzido ou editado como macros VBA para Microsoft Office. O Vim também possui uma linguagem de script chamada Vimscript [5] para criar macros.

Visual Basic for Applications (VBA) é uma linguagem de programação incluída no Microsoft Office do Office 97 ao Office 2019 (embora estivesse disponível em alguns componentes do Office anteriores ao Office 97). No entanto, sua função evoluiu e substituiu as linguagens de macro que foram originalmente incluídas em alguns desses aplicativos.

XEDIT , rodando no componente Conversational Monitor System (CMS) da VM , suporta macros escritas em EXEC , EXEC2 e REXX , e alguns comandos CMS eram na verdade wrappers em torno de macros XEDIT. O Hessling Editor (THE), um clone parcial do XEDIT, suporta macros Rexx usando Regina e Open Object REXX (oorexx). Muitos aplicativos comuns, e alguns em PCs, usam o Rexx como linguagem de script.

Vírus de macro

O VBA tem acesso à maioria das chamadas de sistema do Microsoft Windows e é executado quando os documentos são abertos. Isso torna relativamente fácil escrever vírus de computador no VBA, comumente conhecidos como vírus de macro . Em meados da década de 1990, este se tornou um dos tipos mais comuns de vírus de computador. No entanto, durante o final da década de 1990 e até hoje, a Microsoft vem corrigindo e atualizando seus programas. Além disso, os programas antivírus atuais neutralizam imediatamente esses ataques.

Macro parametrizada

Uma macro parametrizada é uma macro capaz de inserir determinados objetos em sua expansão. Isso dá à macro um pouco do poder de uma função .

Como um exemplo simples, na linguagem de programação C , esta é uma macro típica que não é uma macro parametrizada:

 #definir PI 3.14159

Isso faz PIcom que seja sempre substituído por 3.14159onde quer que ocorra. Um exemplo de macro parametrizada, por outro lado, é este:

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

O que essa macro expande depende de qual argumento x é passado para ela. Aqui estão algumas expansões possíveis:

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

As macros parametrizadas são um mecanismo de nível de origem útil para realizar expansão em linha , mas em linguagens como C , onde usam substituição textual simples, elas têm várias desvantagens graves em relação a outros mecanismos para executar expansão em linha, como funções em linha .

As macros parametrizadas usadas em linguagens como Lisp , PL/I e Scheme , por outro lado, são muito mais poderosas, capazes de tomar decisões sobre qual código produzir com base em seus argumentos; assim, eles podem efetivamente ser usados ​​para executar a geração de código em tempo de execução .


Macros de substituição de texto

Linguagens como C e algumas linguagens assembly possuem macrossistemas rudimentares, implementados como pré -processadores para o compilador ou montador. As macros do pré-processador C funcionam por simples substituição textual no token , em vez do nível de caractere. No entanto, os recursos de macro de montadores mais sofisticados, por exemplo, IBM High Level Assembler (HLASM) não podem ser implementados com um pré-processador; o código para montar instruções e dados é intercalado com o código para montar invocações de macro.

Um uso clássico de macros está no sistema de composição de computador TeX e seus derivados, onde a maior parte da funcionalidade é baseada em macros.

MacroML é um sistema experimental que busca conciliar tipagem estática e macrossistemas. Nemerle digitou macros de sintaxe e uma maneira produtiva de pensar nessas macros de sintaxe é como uma computação de vários estágios .

Outros exemplos:

Alguns aplicativos principais foram escritos como macro de texto invocada por outros aplicativos, por exemplo, por XEDIT no CMS.

Idiomas incorporáveis

Algumas linguagens, como PHP , podem ser incorporadas em texto de formato livre ou no código-fonte de outras linguagens. O mecanismo pelo qual os fragmentos de código são reconhecidos (por exemplo, entre colchetes <?phpe ?>) é semelhante a uma linguagem de macro textual, mas são linguagens muito mais poderosas e com recursos completos. ¹¹¹¹¹

Macros de procedimento

As macros na linguagem PL/I são escritas em um subconjunto da própria PL/I: o compilador executa " instruções de pré -processador " em tempo de compilação, e a saída dessa execução faz parte do código compilado. A capacidade de usar uma linguagem procedural familiar como a linguagem de macros dá um poder muito maior do que as macros de substituição de texto, às custas de um compilador maior e mais lento.

As macros de quadros da tecnologia de quadros têm sua própria sintaxe de comando, mas também podem conter texto em qualquer idioma. Cada quadro é um componente genérico em uma hierarquia de submontagens aninhadas e um procedimento para se integrar com seus quadros de submontagem (um processo recursivo que resolve conflitos de integração em favor de submontagens de nível superior). As saídas são documentos personalizados, geralmente módulos de origem compiláveis. A tecnologia de quadros pode evitar a proliferação de componentes semelhantes, mas sutilmente diferentes, um problema que tem atormentado o desenvolvimento de software desde a invenção de macros e sub- rotinas .

A maioria das linguagens assembly tem recursos de macro procedural menos poderosos, por exemplo, permitindo que um bloco de código seja repetido N vezes para desenrolar o loop ; mas estes têm uma sintaxe completamente diferente da linguagem assembly real.

Macros sintáticas

Sistemas de macro – como o pré-processador C descrito anteriormente – que funcionam no nível de tokens lexicais não podem preservar a estrutura lexical de forma confiável. Os sistemas de macro sintáticos funcionam no nível de árvores sintáticas abstratas e preservam a estrutura lexical do programa original. As implementações mais usadas de sistemas de macro sintáticos são encontradas em linguagens do tipo Lisp . Estas linguagens são especialmente adequadas para este estilo de macro devido à sua sintaxe uniforme entre parênteses (conhecida como S-expressions). Em particular, a sintaxe uniforme torna mais fácil determinar as invocações de macros. As macros Lisp transformam a própria estrutura do programa, com a linguagem completa disponível para expressar tais transformações. Enquanto macros sintáticas são frequentemente encontradas em linguagens do tipo Lisp, elas também estão disponíveis em outras linguagens como Prolog , [6] Erlang , [7] Dylan , [8] Scala , [9] Nemerle , [10] Rust , [11 ] ] Elixir , [12] Nim , [13] Haxe , [14] e Julia . [15]Eles também estão disponíveis como extensões de terceiros para JavaScript , [16] C# [17] e Python . [18]

Macros iniciais do Lisp

Antes do Lisp ter macros, ele tinha os chamados FEXPRs , operadores semelhantes a funções cujas entradas não eram os valores calculados pelos argumentos, mas sim as formas sintáticas dos argumentos, e cuja saída eram valores a serem usados ​​na computação. Em outras palavras, os FEXPRs foram implementados no mesmo nível que o EVAL e forneceram uma janela para a camada de metaavaliação. Este foi geralmente considerado um modelo difícil de raciocinar de forma eficaz. [19]

Em 1963, Timothy Hart propôs adicionar macros ao Lisp 1.5 no AI Memo 57: MACRO Definitions for LISP. [20]

Macros anafóricas

Uma macro anafórica é um tipo de macro de programação que captura deliberadamente alguma forma fornecida à macro que pode ser referida por uma anáfora (uma expressão que se refere a outra). As macros anafóricas apareceram pela primeira vez em On Lisp, de Paul Graham, e seu nome é uma referência à anáfora linguística – o uso de palavras como substituto de palavras precedentes.

Macros higiênicos

Em meados da década de 80, diversos trabalhos [21] [22] introduziram a noção de macroexpansão higiênica ( syntax-rules), um sistema baseado em padrões onde os ambientes sintáticos da definição da macro e do uso da macro são distintos, permitindo que os macrodefinidores e usuários não se preocupem com a captura inadvertida de variáveis ​​(cf. transparência referencial ). As macros higiênicas foram padronizadas para Scheme nos padrões R5RS , R6RS e R7RS . Existem várias implementações concorrentes de macros higiênicas, como syntax-rules, syntax-case, renomeação explícita e fechamentos sintáticos. Ambos syntax-rulese syntax-caseforam padronizados nos padrões do Scheme.

Recentemente, Racket combinou as noções de macros higiênicas com uma " torre de avaliadores ", de modo que o tempo de expansão sintática de um sistema de macro seja o tempo de execução ordinário de outro bloco de código, [23] e mostrou como aplicar expansão intercalada e análise sintática em um idioma sem parênteses. [24]

Várias linguagens além do Scheme implementam macros higiênicas ou implementam sistemas parcialmente higiênicos. Exemplos incluem Scala , Rust , Elixir , Julia , Dylan , Nim e Nemerle .

Aplicativos

Ordem de avaliação
Os sistemas macro têm uma variedade de usos. Ser capaz de escolher a ordem de avaliação (veja avaliação lenta e funções não estritas ) permite a criação de novas construções sintáticas (por exemplo , estruturas de controle ) indistinguíveis daquelas construídas na linguagem. Por exemplo, em um dialeto Lisp que tem condmas não tem if, é possível definir o último em termos do primeiro usando macros. Por exemplo, Scheme tem continuações e macros higiênicas, o que permite que um programador projete suas próprias abstrações de controle, como loops e construções de saída antecipada, sem a necessidade de construí-las na linguagem.
Sub-idiomas de dados e idiomas específicos de domínio
Em seguida, as macros permitem definir linguagens de dados que são compiladas imediatamente em código, o que significa que construções como máquinas de estado podem ser implementadas de maneira natural e eficiente. [25]
Construções de vinculação
As macros também podem ser usadas para introduzir novas construções de ligação. O exemplo mais conhecido é a transformação de letna aplicação de uma função a um conjunto de argumentos.

Felleisen conjectura [26] que essas três categorias constituem os principais usos legítimos de macros em tal sistema. Outros propuseram usos alternativos de macros, como macros anafóricas em macrossistemas que não são higiênicos ou permitem transformação anti-higiênica seletiva.

A interação de macros e outros recursos da linguagem tem sido uma área produtiva de pesquisa. Por exemplo, componentes e módulos são úteis para programação em larga escala, mas a interação de macros e essas outras construções devem ser definidas para uso conjunto. Módulos e sistemas de componentes que podem interagir com macros foram propostos para Scheme e outras linguagens com macros. Por exemplo, a linguagem Racket estende a noção de um sistema de macro para uma torre sintática, onde macros podem ser escritas em linguagens incluindo macros, usando higiene para garantir que as camadas sintáticas sejam distintas e permitindo que os módulos exportem macros para outros módulos.

Macros para software independente de máquina

As macros são normalmente usadas para mapear uma string curta (invocação de macro) para uma sequência mais longa de instruções. Outro uso menos comum de macros é fazer o inverso: mapear uma sequência de instruções para uma string de macro. Essa foi a abordagem adotada pelo STAGE2 Mobile Programming System, que usou um compilador de macro rudimentar (chamado SIMCMP) para mapear o conjunto de instruções específico de um determinado computador em macros independentes de máquina . Aplicativos (principalmente compiladores) escritos nessas macros independentes de máquina podem ser executados sem alterações em qualquer computador equipado com o compilador de macro rudimentar. O primeiro aplicativo executado em tal contexto é um compilador de macro mais sofisticado e poderoso, escrito na linguagem de macro independente de máquina. Este compilador de macro é aplicado a si mesmo, em um bootstrapfashion, para produzir uma versão compilada e muito mais eficiente de si mesmo. A vantagem dessa abordagem é que aplicativos complexos podem ser portados de um computador para um computador muito diferente com muito pouco esforço (para cada arquitetura de máquina de destino, apenas a escrita do compilador de macro rudimentar). [27] [28] O advento das linguagens de programação modernas, notadamente C , para as quais os compiladores estão disponíveis em praticamente todos os computadores, tornou essa abordagem supérflua. Esta foi, no entanto, uma das primeiras instâncias (se não a primeira) de bootstrapping do compilador .

Linguagem de montagem

Embora as instruções de macro possam ser definidas por um programador para qualquer conjunto de instruções do programa assembler nativo, normalmente as macros são associadas a bibliotecas de macro fornecidas com o sistema operacional, permitindo acesso a funções do sistema operacional, como

  • acesso periférico por métodos de acesso (incluindo macros como OPEN, CLOSE, READ e WRITE)
  • funções do sistema operacional como ATTACH, WAIT e POST para criação e sincronização de subtarefas. [29] Normalmente, essas macros se expandem em código executável, por exemplo, para a macroinstrução EXIT,
  • uma lista de instruções constantes de definição , por exemplo, para a macro DCB —DTF (Define The File) para DOS [30] —ou uma combinação de código e constantes, com os detalhes da expansão dependendo dos parâmetros da instrução macro (tal como referência a um arquivo e uma área de dados para uma instrução READ);
  • o código executável geralmente terminava em uma instrução de registro de ramificação e link para chamar uma rotina ou uma instrução de chamada de supervisor para chamar uma função do sistema operacional diretamente.
  • Gerando um fluxo de tarefas do Estágio 2 para geração do sistema em, por exemplo, OS/360 . Ao contrário das macros típicas, as macros do estágio 1 do sysgen não geram dados ou código para serem carregados no armazenamento, mas usam a instrução PUNCH para gerar JCL e dados associados.

Em sistemas operacionais mais antigos, como os usados ​​em mainframes IBM, a funcionalidade completa do sistema operacional estava disponível apenas para programas em linguagem assembler, não para programas em linguagem de alto nível (a menos que sub-rotinas em linguagem assembly fossem usadas, é claro), pois as instruções macro padrão nem sempre têm contrapartidas em rotinas disponíveis para linguagens de alto nível.

História

Em meados da década de 1950, quando a programação em linguagem assembly era comumente usada para escrever programas para computadores digitais , o uso de instruções macro foi iniciado com dois propósitos principais: reduzir a quantidade de codificação de programa que precisava ser escrita, gerando várias instruções em linguagem assembly. de uma instrução de macro e para impor padrões de escrita de programas, por exemplo, especificando comandos de entrada/saída de maneira padrão. [31] As instruções de macro foram efetivamente um passo intermediário entre a programação em linguagem assembly e as linguagens de programação de alto nível que se seguiram, como FORTRAN e COBOL. Duas das primeiras instalações de programação para desenvolver "linguagens macro" para o computador IBM 705 foram na Dow Chemical Corp. em Delaware e no Air Material Command, Ballistics Missile Logistics Office na Califórnia. Uma instrução macro escrita no formato da linguagem assembly alvo seria processada por um compilador de macro, que era um pré-processador para o montador, para gerar uma ou mais instruções em linguagem assembly para serem processadas em seguida pelo programa montador que traduziria o instruções de linguagem assembly em instruções de linguagem de máquina . [32]

No final da década de 1950, a linguagem macro foi seguida pelos Macro Assemblers. Esta foi uma combinação de ambos onde um programa serviu as duas funções, a de um pré-processador de macro e um montador no mesmo pacote. [32] [ falha na verificação ]

Em 1959, Douglas E. Eastwood e Douglas McIlroy da Bell Labs introduziram macros condicionais e recursivas no popular montador SAP , [33] criando o que é conhecido como Macro SAP. [34] O artigo de McIlroy de 1960 foi seminal na área de estender qualquer linguagem de programação (incluindo de alto nível ) através de processadores de macro . [35] [33]

Os Macro Assemblers permitiam que os programadores de linguagem assembly implementassem sua própria macro-linguagem e permitiam portabilidade limitada de código entre duas máquinas executando a mesma CPU, mas sistemas operacionais diferentes, por exemplo, versões anteriores do MSDOS e CPM-86. A biblioteca de macros precisaria ser escrita para cada máquina de destino, mas não para o programa em linguagem assembly geral. Observe que montadores de macro mais poderosos permitiram o uso de construções de montagem condicional em instruções de macro que poderiam gerar código diferente em máquinas diferentes ou sistemas operacionais diferentes, reduzindo a necessidade de várias bibliotecas. [ citação necessária ]

Na década de 1980 e início da década de 1990, os PCs de mesa estavam rodando apenas em alguns MHz e rotinas de linguagem assembly eram comumente usadas para acelerar programas escritos em C, Fortran, Pascal e outros. Essas linguagens, na época, usavam diferentes convenções de chamada. As macros podem ser usadas para fazer a interface de rotinas escritas em linguagem assembly para o front-end de aplicativos escritos em quase qualquer linguagem. Novamente, o código básico da linguagem assembly permaneceu o mesmo, apenas as bibliotecas de macros precisavam ser escritas para cada linguagem de destino. [ citação necessária ]

Em sistemas operacionais modernos, como Unix e seus derivados, o acesso ao sistema operacional é fornecido por meio de sub-rotinas, geralmente fornecidas por bibliotecas dinâmicas. Linguagens de alto nível, como C, oferecem acesso abrangente às funções do sistema operacional, eliminando a necessidade de programas em linguagem assembler para tal funcionalidade. [ citação necessária ]

Veja também

Referências

  1. ^ Oxford English Dictionary , sv macro , macro-instrução e macro-
  2. ^ Greenwald, Irwin D.; Maureen Kane (abril de 1959). "O Sistema Share 709: Programação e Modificação". Jornal da ACM . Nova York, NY, EUA: ACM. 6 (2): 128–133. doi : 10.1145/320964.320967 . S2CID  27424222 . Um dos usos importantes de macros de programador é economizar tempo e erros do tipo clerical na escrita de sequências de instruções que são frequentemente repetidas no decorrer de um programa.
  3. ^ Strachey, Christopher (outubro de 1965). "Um Macrogerador de Uso Geral" . Diário do Computador . 8 (3): 225–241. doi : 10.1093/comjnl/8.3.225 .
  4. ^ "Runescape: The Massive Online Adventure Game da Jagex Ltd" . Recuperado em 2008-04-03 .
  5. ^ "scripts: vim online" . www.vim.org .
  6. ^ "Macros de prólogo" . www.metalevel.at . Recuperado 2021-04-05 .
  7. ^ "Erlang -- Pré-processador" . erlang.org . Recuperado 2021-05-24 .
  8. ^ "O Dylan Macro System - Abra Dylan" . opendylan.org . Recuperado 2021-04-05 .
  9. ^ "Def Macros" . Documentação Escala . Recuperado 2021-04-05 .
  10. ^ "Sobre - Site oficial da linguagem de programação Nemerle" . nemerle.org . Recuperado 2021-04-05 .
  11. ^ "Macros - A linguagem de programação Rust" . doc.rust-lang.org . Recuperado 2021-04-05 .
  12. ^ "Macros" . elixir-lang.github.com . Recuperado 2021-04-05 .
  13. ^ "macro" . nim-lang.org . Recuperado 2021-04-05 .
  14. ^ "Macros" . Haxe - O kit de ferramentas multiplataforma .
  15. ^ "Metaprogramação · A Linguagem Julia" . docs.julialang.org . Recuperado 2021-04-05 .
  16. ^ "Sweet.js - Macros higiênicas para JavaScript" . www.sweetjs.org .
  17. ^ "Página inicial do LeMP · C# aprimorado" . ecsharp.net .
  18. ^ "Macros em Python: quase aspas, classes de caso, LINQ e mais!: lihaoyi/macropy" . 7 de fevereiro de 2019 – via GitHub.
  19. ^ Marshall, Joe. "e-mail sem título" . Recuperado em 3 de maio de 2012 .
  20. ^ Hart, Timothy P. (outubro de 1963). "AIM-057, Definições de MACRO para LISP, Timothy P. Hart". hdl : 1721.1/6111 . {{cite journal}}:Cite journal requer |journal=( ajuda )
  21. ^ Kohlbecker, Eugene; Friedman, Daniel; Felleisen, Matthias; Duba, Bruce. "Expansão Macro higiênica". doi : 10.1145/319838.319859 .
  22. ^ [1] Clinger, Rees. "Macros que funcionam"
  23. ^ Flatt, Mateus. "Macros combináveis ​​e compiláveis: você quer quando?" (PDF) .
  24. ^ Rafkind, Jon; Flatt, Mateus. "Honu: extensão sintática para notação algébrica através de florestamento" (PDF) .
  25. ^ "Autômatos via Macros" . cs.brown.edu .
  26. ^ [2] , Matthias Felleisen, LL1 postagem na lista de discussão
  27. ^ Orgass, Richard J.; William M. Waite (setembro de 1969). "Uma base para um sistema de programação móvel". Comunicações da ACM . Nova York, NY, EUA: ACM. 12 (9): 507-510. doi : 10.1145/363219.363226 . S2CID 8164996 . 
  28. ^ Waite, William M. (julho de 1970). "O sistema de programação móvel: STAGE2". Comunicações da ACM . Nova York, NY, EUA: ACM. 13 (7): 415–421. doi : 10.1145/362686.362691 . S2CID 11733598 . 
  29. ^ "Universidade do Norte da Flórida" (PDF) .
  30. ^ "DTF (DOS/VSE)" .
  31. ^ "Centro de Conhecimento IBM" . Centro de Conhecimento IBM . 16 de agosto de 2013.
  32. ^ a b "Instruções Macro da linguagem Assembler" . Cisco .
  33. ^ a b Holbrook, Bernard D.; Brown, W. Stanley. "Computing Science Technical Report No. 99 - A History of Computing Research at Bell Laboratories (1937-1975)" . Laboratórios Bell . Arquivado do original em 2 de setembro de 2014 . Recuperado em 2 de fevereiro de 2020 .
  34. ^ "Macro SAP - modificação do compilador de macro do SAP" . HOPL: Enciclopédia Histórica Online de Linguagens de Programação . Arquivado do original em 13 de agosto de 2008.
  35. ^ Layzell, P. (1985). "A história dos processadores de macro na extensibilidade da linguagem de programação" . O Diário do Computador . 28 (1): 29–33. doi : 10.1093/comjnl/28.1.29 .

Links externos