Macro (ciencias de la computación)

j editor macro de Editar

En programación informática, una macro (abreviatura de "macro instrucción"; del griego μακρο- &# 39;largo, grande') es una regla o patrón que especifica cómo se debe asignar una determinada entrada a una salida de reemplazo. Aplicar una macro a una entrada se conoce como expansión de macro. La entrada y la salida pueden ser una secuencia de tokens o caracteres léxicos, o un árbol sintáctico. Las macros de caracteres son compatibles con las aplicaciones de software para facilitar la invocación de secuencias de comandos comunes. Las macros de token y árbol son compatibles con algunos lenguajes de programación para permitir la reutilización de código o para ampliar el lenguaje, a veces para lenguajes específicos de dominio.

Las macros se utilizan para hacer que una secuencia de instrucciones informáticas esté disponible para el programador como una declaración de programa única, lo que hace que la tarea de programación sea menos tediosa y menos propensa a errores. (Por lo tanto, se denominan "macros" porque un bloque de código "grande" se puede expandir a partir de una secuencia de caracteres "pequeña"). parámetros de palabras clave que dictan lo que genera el programa ensamblador condicional y se han utilizado para crear programas completos o conjuntos de programas de acuerdo con variables como el sistema operativo, la plataforma u otros factores. El término deriva de "macroinstrucción", y dichas expansiones se usaron originalmente para generar código en lenguaje ensamblador.

Macros de teclado y ratón

Las macros de teclado y las macros de ratón permiten que secuencias cortas de pulsaciones de teclas y acciones del ratón se transformen en otras secuencias de pulsaciones de teclas y acciones del ratón, que normalmente consumen más tiempo. De esta forma, se pueden automatizar secuencias repetitivas o de uso frecuente de pulsaciones de teclas y movimientos del ratón. Los programas independientes para crear estas macros se denominan grabadoras de macros.

Durante la década de 1980, los programas de macro (originalmente SmartKey, luego SuperKey, KeyWorks, Prokey) fueron muy populares, primero como un medio para dar formato automáticamente a los guiones y luego para una variedad de tareas de entrada del usuario. Estos programas se basaron en el modo de operación TSR (terminar y permanecer residente) y se aplicaron a todas las entradas de teclado, sin importar en qué contexto ocurrieron. Hasta cierto punto, han caído en obsolescencia tras la llegada de las interfaces de usuario controladas por mouse y la disponibilidad de macros de teclado y mouse en aplicaciones como procesadores de texto y hojas de cálculo, lo que hace posible crear macros de teclado sensibles a la aplicación.

Las macros de teclado se pueden usar en juegos de rol multijugador masivos en línea (MMORPG) para realizar tareas repetitivas, pero lucrativas, y así acumular recursos. Como esto se hace sin esfuerzo humano, puede sesgar la economía del juego. Por esta razón, el uso de macros es una violación de los TOS o EULA de la mayoría de los MMORPG, y sus administradores hacen un esfuerzo considerable para suprimirlos.

Macros de aplicaciones y secuencias de comandos

Las macros de teclado y mouse que se crean utilizando las funciones de macro integradas de una aplicación a veces se denominan macros de aplicación. Se crean realizando la secuencia una vez y dejando que la aplicación registre las acciones. También puede existir un lenguaje de programación de macros subyacente, más comúnmente un lenguaje de secuencias de comandos, con acceso directo a las funciones de la aplicación.

Los programadores' editor de texto, Emacs, (abreviatura de "editar macros") sigue esta idea hasta una conclusión. En efecto, la mayor parte del editor está hecho de macros. Emacs se concibió originalmente como un conjunto de macros en el lenguaje de edición TECO; más tarde fue portado a dialectos de Lisp.

Otros programadores' editor de texto, Vim (un descendiente de vi), también tiene una implementación de macros de teclado. Puede grabar en un registro (macro) lo que una persona escribe en el teclado y puede reproducirse o editarse como las macros de VBA para Microsoft Office. Vim también tiene un lenguaje de secuencias de comandos llamado Vimscript para crear macros.

Visual Basic para Aplicaciones (VBA) es un lenguaje de programación incluido en Microsoft Office desde Office 97 hasta Office 2019 (aunque estaba disponible en algunos componentes de Office antes de Office 97). Sin embargo, su función ha evolucionado y reemplazado los lenguajes de macros que se incluyeron originalmente en algunas de estas aplicaciones.

XEDIT, que se ejecuta en el componente Conversational Monitor System (CMS) de VM, admite macros escritas en EXEC, EXEC2 y REXX, y algunos comandos CMS en realidad envolvían las macros XEDIT. Hessling Editor (THE), un clon parcial de XEDIT, admite macros Rexx con Regina y Open Object REXX (oorexx). Muchas aplicaciones comunes, y algunas en PC, usan Rexx como lenguaje de secuencias de comandos.

Macrovirus

VBA tiene acceso a la mayoría de las llamadas al sistema de Microsoft Windows y se ejecuta cuando se abren los documentos. Esto hace que sea relativamente fácil escribir virus informáticos en VBA, comúnmente conocidos como virus de macro. A mediados y finales de la década de 1990, se convirtió en uno de los tipos de virus informáticos más comunes. Sin embargo, desde fines de la década de 1990 y hasta la fecha, Microsoft ha estado parcheando y actualizando sus programas. Además, los programas antivirus actuales contrarrestan inmediatamente tales ataques.

Macro parametrizado

Una macro parametrizada es una macro que puede insertar objetos dados en su expansión. Esto le da a la macro parte del poder de una función.

Como ejemplo simple, en el lenguaje de programación C, esta es una macro típica que no es una macro parametrizada:

 #define PI 3.14159

Esto hace que PI siempre se reemplace con 3.14159 donde sea que ocurra. Un ejemplo de una macro parametrizada, por otro lado, es este:

 #define (x) (x)-1)

A qué se expande esta macro depende del argumento x que se le pase. Aquí hay algunas expansiones posibles:

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

Las macros parametrizadas son un mecanismo útil a nivel de fuente para realizar la expansión en línea, pero en lenguajes como C, donde usan sustitución textual simple, tienen una serie de desventajas graves sobre otros mecanismos para realizar la expansión en línea, como como funciones en línea.

Las macros parametrizadas utilizadas en lenguajes como Lisp, PL/I y Scheme, por otro lado, son mucho más poderosas, capaces de tomar decisiones sobre qué código producir en función de sus argumentos; por lo tanto, se pueden usar de manera efectiva para realizar la generación de código en tiempo de ejecución.

Macros de sustitución de texto

Los lenguajes como C y algunos lenguajes ensambladores tienen sistemas de macros rudimentarios, implementados como preprocesadores para el compilador o ensamblador. Las macros de preprocesador de C funcionan mediante una simple sustitución textual en el token, en lugar de a nivel de carácter. Sin embargo, las funciones macro de ensambladores más sofisticados, por ejemplo, IBM High Level Assembler (HLASM) no se pueden implementar con un preprocesador; el código para ensamblar instrucciones y datos se intercala con el código para ensamblar invocaciones de macros.

Un uso clásico de las macros es el sistema de composición tipográfica TeX y sus derivados, donde la mayor parte de la funcionalidad se basa en macros.

MacroML es un sistema experimental que busca reconciliar sistemas macro y de escritura estática. Nemerle ha escrito macros de sintaxis, y una forma productiva de pensar en estas macros de sintaxis es como un cálculo de varias etapas.

Otros ejemplos:

• m4 es un sofisticado procesador macro independiente.
• TRAC
• Extensión de Macro TAL, lenguaje atributo de la plantilla
• SMX: para páginas web
• ML/1 (Macro Language One)
• El Macrogenerador de Propósito General es un procesador macro contextual que puede describirse como una combinación de expresiones regulares, EBNF y AWK
• troff and nroff: para la clasificación y el formato de las páginas de Unix.
• CMS EXEC: para macros de línea de comandos y macros de aplicación
• EXEC 2 en Sistema de Monitor Conversacional (CMS): para macros de línea de comandos y macros de aplicación
• CLIST en la opción de compartir tiempo de IBM (TSO): para macros de línea de comandos y macros de aplicación
• REXX: para macros de línea de comandos y macros de aplicaciones en, por ejemplo, AmigaOS, CMS, OS/2, TSO
• SCRIPT: for formatting documents
• Diferentes cáscaras para, por ejemplo, Linux

Algunas de las principales aplicaciones se han escrito como macros de texto invocadas por otras aplicaciones, por ejemplo, por XEDIT en CMS.

Idiomas integrables

Algunos lenguajes, como PHP, se pueden incrustar en texto de formato libre o en el código fuente de otros lenguajes. El mecanismo por el cual se reconocen los fragmentos de código (por ejemplo, entre paréntesis <?php y ?>) es similar a un lenguaje de macros textual, pero son lenguajes mucho más potentes y con todas las funciones.

Macros de procedimiento

Las macros en el lenguaje PL/I se escriben en un subconjunto del mismo PL/I: el compilador ejecuta "sentencias de preprocesador" en tiempo de compilación, y la salida de esta ejecución forma parte del código que se compila. La capacidad de usar un lenguaje de procedimiento familiar como lenguaje de macros brinda un poder mucho mayor que el de las macros de sustitución de texto, a expensas de un compilador más grande y más lento.

Las macros de marco de la tecnología de marcos tienen su propia sintaxis de comandos, pero también pueden contener texto en cualquier idioma. Cada marco es a la vez un componente genérico en una jerarquía de subensamblajes anidados y un procedimiento para integrarse con sus marcos de subensamblaje (un proceso recursivo que resuelve los conflictos de integración a favor de subensamblajes de nivel superior). Los resultados son documentos personalizados, típicamente módulos fuente compilables. La tecnología de marcos puede evitar la proliferación de componentes similares pero sutilmente diferentes, un problema que ha plagado el desarrollo de software desde la invención de las macros y las subrutinas.

La mayoría de los lenguajes ensambladores tienen funciones de macro de procedimiento menos potentes, por ejemplo, que permiten que un bloque de código se repita N veces para que se desenrolle el bucle; pero estos tienen una sintaxis completamente diferente del lenguaje ensamblador real.

Macros sintácticos

Los macrosistemas, como el preprocesador C descrito anteriormente, que funcionan a nivel de tokens léxicos no pueden preservar la estructura léxica de manera confiable. Los macrosistemas sintácticos funcionan en cambio a nivel de árboles sintácticos abstractos y conservan la estructura léxica del programa original. Las implementaciones más utilizadas de sistemas de macros sintácticos se encuentran en lenguajes similares a Lisp. Estos lenguajes son especialmente adecuados para este estilo de macro debido a su sintaxis uniforme entre paréntesis (conocida como expresiones S). En particular, la sintaxis uniforme facilita la determinación de las invocaciones de macros. Las macros de Lisp transforman la estructura del programa en sí, con el lenguaje completo disponible para expresar tales transformaciones. Si bien las macros sintácticas a menudo se encuentran en lenguajes similares a Lisp, también están disponibles en otros lenguajes como Prolog, Erlang, Dylan, Scala, Nemerle, Rust, Elixir, Nim, Haxe y Julia. También están disponibles como extensiones de terceros para JavaScript, C# y Python.

Primeras macros de Lisp

Antes de que Lisp tuviera macros, tenía los llamados FEXPR, operadores similares a funciones cuyas entradas no eran los valores calculados por los argumentos sino las formas sintácticas de los argumentos, y cuya salida eran los valores que se utilizarían en el cálculo. En otras palabras, los FEXPR se implementaron al mismo nivel que EVAL y proporcionaron una ventana a la capa de metaevaluación. En general, se encontró que este era un modelo difícil de razonar de manera efectiva.

En 1963, Timothy Hart propuso agregar macros a Lisp 1.5 en AI Memo 57: Definiciones de MACRO para LISP.

Macros anafóricos

Una macro anafórica es un tipo de macro de programación que captura deliberadamente alguna forma proporcionada a la macro a la que se puede hacer referencia mediante una anáfora (una expresión que se refiere a otra). Las macros anafóricas aparecieron por primera vez en On Lisp de Paul Graham y su nombre es una referencia a la anáfora lingüística: el uso de palabras como sustituto de las palabras precedentes.

Macros higiénicos

A mediados de los años ochenta, varios artículos introdujeron la noción de expansión macro higiénica (syntax-rules), un sistema basado en patrones donde los entornos sintácticos de la definición macro y el uso macro son distintos, lo que permite a los definidores de macros y a los usuarios no preocuparse por la captura de variables involuntarias (cf. transparencia referencial). Las macros higiénicas se han estandarizado para Scheme en los estándares R5RS, R6RS y R7RS. Existen varias implementaciones competitivas de macros higiénicas, como syntax-rules, syntax-case, cambio de nombre explícito y cierres sintácticos. Tanto syntax-rules como syntax-case se han estandarizado en los estándares del Esquema.

Recientemente, Racket ha combinado las nociones de macros higiénicas con una "torre de evaluadores", de modo que el tiempo de expansión sintáctica de un sistema macro es el tiempo de ejecución ordinario de otro bloque de código, y mostró cómo aplicar la expansión y el análisis intercalados en un idioma sin paréntesis.

Varios lenguajes además de Scheme implementan macros higiénicas o implementan sistemas parcialmente higiénicos. Los ejemplos incluyen Scala, Rust, Elixir, Julia, Dylan, Nim y Nemerle.

Aplicaciones

Orden de evaluación

Los sistemas Macro tienen una gama de usos. Ser capaz de elegir el orden de evaluación (ver las funciones de evaluación perezosa y no restricciones) permite la creación de nuevos constructos sintácticos (por ejemplo, estructuras de control) indistinguibles de los incorporados al lenguaje. Por ejemplo, en un dialecto lisp que tiene cond pero falta if, es posible definir este último en términos de los primeros utilizando macros. Por ejemplo, Scheme tiene tanto las continuas como las macros higiénicas, lo que permite a un programador diseñar sus propias abstracciones de control, tales como las construcciones de bucle y salida temprana, sin la necesidad de construirlas en el idioma.

Subsidios de datos e idiomas específicos de dominio

A continuación, los macros permiten definir lenguajes de datos que se compilan inmediatamente en código, lo que significa que construcciones como máquinas estatales pueden ser implementadas de una manera que sea tanto natural como eficiente.

Construcciones vinculantes

Macros también se puede utilizar para introducir nuevos constructos vinculantes. El ejemplo más conocido es la transformación de let en la aplicación de una función a un conjunto de argumentos.

Felleisen conjetura que estas tres categorías constituyen los principales usos legítimos de las macros en dicho sistema. Otros han propuesto usos alternativos de macros, como macros anafóricas en sistemas macro que no son higiénicos o permiten una transformación antihigiénica selectiva.

La interacción de macros y otras características del lenguaje ha sido un área productiva de investigación. Por ejemplo, los componentes y módulos son útiles para la programación a gran escala, pero la interacción de las macros y estas otras construcciones debe definirse para su uso conjunto. Se han propuesto sistemas de módulos y componentes que pueden interactuar con macros para Scheme y otros lenguajes con macros. Por ejemplo, el lenguaje Racket extiende la noción de un sistema macro a una torre sintáctica, donde las macros se pueden escribir en lenguajes que incluyen macros, usando higiene para garantizar que las capas sintácticas sean distintas y permitiendo que los módulos exporten macros a otros módulos.

Macros para software independiente de la máquina

Las macros se utilizan normalmente para asignar una cadena corta (invocación de macro) a una secuencia más larga de instrucciones. Otro uso menos común de las macros es hacer lo contrario: asignar una secuencia de instrucciones a una cadena de macros. Este fue el enfoque adoptado por el sistema de programación móvil STAGE2, que utilizó un compilador de macros rudimentario (llamado SIMCMP) para mapear el conjunto de instrucciones específico de una computadora determinada en macros independientes de la máquina. Las aplicaciones (especialmente los compiladores) escritas en estas macros independientes de la máquina se pueden ejecutar sin cambios en cualquier computadora equipada con el compilador de macros rudimentario. La primera aplicación que se ejecuta en dicho contexto es un compilador de macros más sofisticado y potente, escrito en el lenguaje de macros independiente de la máquina. Este compilador de macros se aplica a sí mismo, en forma de arranque, para producir una versión compilada y mucho más eficiente de sí mismo. La ventaja de este enfoque es que las aplicaciones complejas se pueden trasladar de una computadora a una computadora muy diferente con muy poco esfuerzo (para cada arquitectura de máquina de destino, solo es necesario escribir el compilador de macros rudimentario). El advenimiento de los lenguajes de programación modernos, en particular C, para los cuales los compiladores están disponibles en prácticamente todas las computadoras, ha hecho que este enfoque sea superfluo. Sin embargo, esta fue una de las primeras instancias (si no la primera) de arranque del compilador.

Lenguaje ensamblador

Si bien las instrucciones de macro pueden ser definidas por un programador para cualquier conjunto de instrucciones de programa de ensamblador nativo, normalmente las macros están asociadas con bibliotecas de macros entregadas con el sistema operativo que permiten el acceso a funciones del sistema operativo como

• acceso periférico por métodos de acceso (incluyendo macros como OPEN, CLOSE, READ y WRITE)
• funciones del sistema operativo como ATTACH, WAIT y POST para la creación y sincronización de subtascos. Típicamente tales macros se expanden en código ejecutable, por ejemplo, para la macroinstrucción EXIT,
• a list of definir constante instrucciones, por ejemplo, para el macro-DTF DCB (Define The File) para DOS, o una combinación de código y constantes, con los detalles de la expansión dependiendo de los parámetros de la instrucción macro (como una referencia a un archivo y un área de datos para una instrucción READ);
• el código ejecutable a menudo termina en filial y registro de enlaces instrucciones para llamar a una rutina, o una instrucción de llamada para llamar directamente a una función del sistema operativo.
• Generando un Etapa 2 flujo de trabajo para la generación del sistema, por ejemplo, OS/360. A diferencia de las macros típicas, las macros de la etapa 1 del sísgen no generan datos ni códigos para ser cargados en el almacenamiento, sino que utilizan el PUNCH declaración a la salida JCL y datos asociados.

En los sistemas operativos más antiguos, como los que se utilizan en los mainframes de IBM, la funcionalidad completa del sistema operativo solo estaba disponible para los programas en lenguaje ensamblador, no para los programas en lenguaje de alto nivel (a menos que se usaran subrutinas en lenguaje ensamblador, por supuesto), como las instrucciones macro estándar. no siempre tuvo contrapartes en las rutinas disponibles para los lenguajes de alto nivel.

Historia

A mediados de la década de 1950, cuando la programación en lenguaje ensamblador se usaba comúnmente para escribir programas para computadoras digitales, se inició el uso de macroinstrucciones con dos propósitos principales: reducir la cantidad de codificación de programas que tenía que escribirse generando varias sentencias en lenguaje ensamblador a partir de una instrucción macro y para hacer cumplir los estándares de escritura del programa, p. especificando comandos de entrada/salida en formas estándar. Las macro instrucciones fueron efectivamente un paso intermedio entre la programación en lenguaje ensamblador y los lenguajes de programación de alto nivel que siguieron, como FORTRAN y COBOL. Dos de las primeras instalaciones de programación para desarrollar "macro lenguajes" para la computadora IBM 705 estaban en Dow Chemical Corp. en Delaware y el Comando de Material Aéreo, Oficina de Logística de Misiles Balísticos en California. Una instrucción de macro escrita en el formato del lenguaje ensamblador de destino sería procesada por un compilador de macros, que era un preprocesador del ensamblador, para generar una o más instrucciones en lenguaje ensamblador para ser procesadas a continuación por el programa ensamblador que traduciría el instrucciones en lenguaje ensamblador a instrucciones en lenguaje máquina.

A fines de la década de 1950, el lenguaje de macros fue seguido por los ensambladores de macros. Esta fue una combinación de ambos donde un programa cumplió ambas funciones, la de un preprocesador de macros y un ensamblador en el mismo paquete.

En 1959, Douglas E. Eastwood y Douglas McIlroy de Bell Labs introdujeron macros condicionales y recursivas en el popular ensamblador SAP, creando lo que se conoce como Macro SAP. El artículo de McIlroy de 1960 fue fundamental en el área de extender cualquier lenguaje de programación (incluido el de alto nivel) a través de macroprocesadores.

Los ensambladores de macros permitieron a los programadores del lenguaje ensamblador implementar su propio lenguaje de macros y permitieron una portabilidad limitada del código entre dos máquinas que ejecutaban la misma CPU pero diferentes sistemas operativos, por ejemplo, versiones anteriores de MSDOS y CPM-86. La biblioteca de macros debería escribirse para cada máquina de destino, pero no para el programa de lenguaje ensamblador general. Tenga en cuenta que los ensambladores de macros más potentes permitieron el uso de construcciones de ensamblaje condicional en instrucciones de macro que podrían generar código diferente en diferentes máquinas o diferentes sistemas operativos, lo que reduce la necesidad de múltiples bibliotecas.

En la década de 1980 y principios de la de 1990, las PC de escritorio solo funcionaban a unos pocos MHz y las rutinas de lenguaje ensamblador se usaban comúnmente para acelerar los programas escritos en C, Fortran, Pascal y otros. Estos idiomas, en ese momento, usaban diferentes convenciones de llamadas. Las macros se pueden usar para interconectar rutinas escritas en lenguaje ensamblador con el front-end de aplicaciones escritas en casi cualquier idioma. Una vez más, el código básico del lenguaje ensamblador siguió siendo el mismo, solo era necesario escribir las bibliotecas de macros para cada idioma de destino.

En los sistemas operativos modernos como Unix y sus derivados, el acceso al sistema operativo se proporciona a través de subrutinas, generalmente proporcionadas por bibliotecas dinámicas. Los lenguajes de alto nivel como C ofrecen acceso integral a las funciones del sistema operativo, lo que elimina la necesidad de programas de lenguaje ensamblador para dicha funcionalidad.