Макросы — это чистые функции, исполняемые во время компиляции

Макросы в том виде, в котором они реализованы в Си и в его продолжателе C++, говорят о недоразвитости языка, поверх которого они работают. В самом деле, если язык так хорош, то зачем ему макросы? А потому они и нужны, что частенько чего-то не хватает и требуется расширить язык средствами другого языка. Макросы помогают спрятать недостатки основного языка. Язык макросов в Си и в C++ — это по сути это отдельный язык, имеющий мало общего с тем, поверх которого он выполнен.

Во-первых, он не типизирован. Сочетание типизации в основном языке и отсутствие её в макросах противоречиво. Оно порою приводит к трудностям при компиляции, ошибки в макросах разгадываются порою труднее обычного.

Второй особенностью языка макросов является то обстоятельство, что макросы исполняются исключительно во время компиляции. То есть исполнение макросов — это транспиляция в основной язык.

А в-третьих результатом работы препроцессора является видоизменённый текст на основном языке. В то время как основной язык компилируется в исполняемый код.

Страуструп, автор C++:

Практически каждый макрос свидетельствует о недостатке в языке программирования, программе или программисте.

Страуструпу макросы достались в наследство от Си. Но, несмотря на отрицательное к ним отношение, он вынужден был включить их в C++ для обеспечения совместимости.

Если вспомнить, что макросы работают во время компиляции, то вывод из этого можно сделать такой. Входные аргументы макросов известны во время компиляции, то есть являются константами. Ещё один вывод: макросы являются чистыми функциями, раз их можно выполнить во время компиляции.

Из этих двух фактов вытекает третий: результаты работы чистых функции, имеющих своими аргументами константы, могут быть вычислены во время компиляции. То есть чистые функции играют роль макросов и могут собою их заменить.

Из этого можно сделать четвёртый вывод: отдельный язык макросов, который работает поверх основного языка, не нужен. Достаточно в языке иметь чистые функции, тогда константные аргументы делают их макросами. Например:

x = 2 * 2		// операция "*" — чистая, вычисление 
			// результата возможно во время компиляции
y = sin(0)		// функция sin —чистая
ctg = cos(0)/sin(0)	// ошибка (деление на 0) выявляется при компиляцци
z = "число равно " + число в строку(x)
			// конкатенация строк во время компиляции
итого = сумма прописью (зарплата + премия)
			// если "сумма прописью" — чистая, а "зарплата" и "премия" — 
			// константы, то это вычисляется во время компиляции

Кстати, в Си есть псевдофункция sizeof(), которая чиста, имеет константный аргумент и работает во время компиляции. Предписание #include хотя и выполняет чтение файла, делает это во время компиляции. Следовательно, оно чисто.

Заключение

Любой язык программирования не нуждается в макросах, если в нём есть чистые функции — которые либо поддерживаются синтаксисом, либо свойство чистоты функции выводится на основании чистоты всех функций, в неё включенных, например:

int  F (int  a, int  b) {
	x = f1 (a);	// f1 — чистая
	y = f2 (b);	// f2 — чистая
	z = f3 (x, y);	// f4 — чистая
	return  z;	// в итоге F тоже чистая
}

Надо отметить, что развитие C++ идёт в направлении, в том числе, всё большего развития constexpr — вычисления выражений с константными аргументами. Но, надо сказать, что в C++ чистые функции не поддержаны синтаксисом. Вывод свойства чистоты у функций затруднён из-за правил этого языка, а в ряде случаев просто невозможен. Пока она лишь немного выходит за рамки арифметических и логических операций, свойство чистоты которых очевидно. Поэтому свёртка и распространение констант не могут быть глубокими. Поэтому выжать максимум в этом плане C++ не удастся. Это как раз тот случай, когда C++ вынуден поддерживать обратную совместимость, отрезая себе путь к совершенству. Но это уже другая тема.

Что нужно компилятору, чтобы заменять чистые функции с константными аргументами на результаты их работы? Для этого в состав компилятора должен войти интерпретатор, который бы искал в промежуточном представлении программы участки, которые можно выполнить на этапе компиляции. И, выполняя чистые функции с константными аргументами, заменял бы их результатами вычислений.

Опубликовано: 2022.03.21, последняя правка: 2022.05.04    18:13

     2022/08/23 13:34, Ильдар          # 

ошибки в макросах разгадываются порою труднее обычного.

     2022/08/30 18:10, void          # 

• HLA aka High Level Assembly by Randy Hide == такой занятный "ассемблер высокого уровня"
  
  Здесь мы видим синтаксис Паскаля, семантику скорее С++ (и даже вариант реализации STL, ООП, Win32 GUI) и довольно высокоуровневую стандартную библиотеку. STL и ООП построены на своём макроязыке. Он достаточно мощный чтобы обеспечивать рефлексивность, интроспекцию, CTFE = compile-time function execution.
  
  Этот "надассемблер" затем транслируется в обычный GAS/MASM/FASM или компилируется напрямую сразу в бинарник.
• D с типизированными макросами разных видов: template mixin, template, string mixin
• да даже PL/1! вы будете смеяться, но вот есть книжка про OS/2+PL/1. Там есть пример реализации PARSE конструкции из языка REXX на строковых макросах PL/1 как DSL. Макроязык PL/1 в реализации от IBM достаточно мощный, чтобы можно было вручную сконструировать текстовую строчку и подать её к компиляции.
• Лиспы, тысячи их: начиная от простых интерпретируемых типа PicoLisp, NewLisp и прочих Lisp 1.5 до более удобных для компиляции.
  
  CrystalLisp https://github.com/vygr/ChrysaLisp от Chis Hinsley, автора Automania и прочих игрушек 80х, а также операционной среды/системы/виртуальной машины ElateOS, Tao OS (гуглите по ссылкам в профиле автора на Гитхабе, в Википедии, Вебархиве и osnews.com интервью). Как виртуальная машина — она реализовывала VPasm, виртуальный ассемблер (с бесконечным количеством регистров). В этом смысле немного напоминала LLVM bitcode, но если в LLVM представление SSA более удобно для компиляции и оптимизации, то здесь довольно простая и компактная кроссплатформенная реализация. Почитайте, там много интересного.
• Sassy на Guile Scheme — ассемблер как макросы на Scheme.
• Процедурные макросы Rust и например, реализация Форта на таких макросах.
• DSL для Форта в виде встраиваемого ассемблера

     2022/09/03 23:35, Автор сайта          # 

да даже PL/1! Вы будете смеяться

     2022/09/06 19:46, void          # 

Идея статьи не в том, как сделать макросы развитыми и удобными. А о том, чтобы сделать язык развитым и удобным.

Макросы в том виде, в котором они реализованы в Си и в его продолжателе C++, говорят о недоразвитости языка, поверх которого они работают. В самом деле, если язык так хорош, то зачем ему макросы? А потому они и нужны, что частенько чего-то не хватает и требуется расширить язык средствами другого языка. Макросы помогают спрятать недостатки основного языка. Язык макросов в Си и в C++ — это по сути это отдельный язык, имеющий мало общего с тем, поверх которого он выполнен.

• парсер MOC реализован отдельной утилитой.
• из этого кодогенератор генерирует исходники на С++ c макросами, которые обрабатывают "сущности метаязыка" — SIGNAL, SLOT, подписку на события-обработчики.

Язык является низкоуровневым — когда программы на этом языке переполнены подробной информацией о несущественном.

Алан Перлис

Предписание #include хотя и выполняет чтение файла, делает это во время компиляции. Следовательно, оно чисто.

#ifndef WIN32_LEAN_AND_MEAN
    #include <cderr.h>
    #include <dde.h>
    #include <ddeml.h>
    #include <dlgs.h>
    #ifndef _MAC
        #include <lzexpand.h>
        #include <mmsystem.h>
        #include <nb30.h>
        #include <rpc.h>
    #endif
    #include <shellapi.h>
    #ifndef _MAC
        #include <winperf.h>
        #include <winsock.h>
    #endif
    #ifndef NOCRYPT
        #include <wincrypt.h>
        #include <winefs.h>
        #include <winscard.h>
    #endif

    #ifndef NOGDI
        #ifndef _MAC
            #include <winspool.h>
            #ifdef INC_OLE1
                #include <ole.h>
            #else
                #include <ole2.h>
            #endif /* !INC_OLE1 */
        #endif /* !MAC */
        #include <commdlg.h>
    #endif /* !NOGDI */
#endif /* WIN32_LEAN_AND_MEAN */

#undef UNICODE

#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdlib.h>
#include <stdio.h>

// Need to link with Ws2_32.lib
#pragma comment (lib, "Ws2_32.lib")
// #pragma comment (lib, "Mswsock.lib")

#define DEFAULT_BUFLEN 512
#define DEFAULT_PORT "27015"

int __cdecl main(void) 
{
    WSADATA wsaData;
    int iResult;

    SOCKET ListenSocket = INVALID_SOCKET;
    SOCKET ClientSocket = INVALID_SOCKET;

    struct addrinfo *result = NULL;
    struct addrinfo hints;

    int iSendResult;
    char recvbuf[DEFAULT_BUFLEN];
    int recvbuflen = DEFAULT_BUFLEN;
    
    // <<Initialize Winsock>> 
    iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed with error: %d\n", iResult);
        return 1;
    }

    ZeroMemory(&hints, sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;
    hints.ai_flags = AI_PASSIVE;

    // <<Resolve the server address and port>>
    iResult = getaddrinfo(NULL, DEFAULT_PORT, &hints, &result);
    if ( iResult != 0 ) {
        printf("getaddrinfo failed with error: %d\n", iResult);
        WSACleanup();
        return 1;
    }

    // <<Create a SOCKET for the server to listen for client connections>>.
    ListenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol);
    if (ListenSocket == INVALID_SOCKET) {
///TL;DR ....
        WSACleanup();
        return 1;
    }

    // Setup the TCP listening socket
    iResult = bind( ListenSocket, result->ai_addr, (int)result->ai_addrlen);
    if (iResult == SOCKET_ERROR) {
///TL;DR
        WSACleanup();
        return 1;
    }

    freeaddrinfo(result);

    iResult = listen(ListenSocket, SOMAXCONN);
    if (iResult == SOCKET_ERROR) {
///TL;DR ...
        WSACleanup();
        return 1;
    }

    // Accept a client socket
    ClientSocket = accept(ListenSocket, NULL, NULL);
    if (ClientSocket == INVALID_SOCKET) {
///TL;DR ...
        WSACleanup();
        return 1;
    }

    // No longer need server socket
    closesocket(ListenSocket);

    // Receive until the peer shuts down the connection
    do {

        iResult = recv(ClientSocket, recvbuf, recvbuflen, 0);
        if (iResult > 0) {
        /// <<Handle request>> 

        // <<Echo the buffer back to the sender>>
            iSendResult = send( ClientSocket, recvbuf, iResult, 0 );
            if (iSendResult == SOCKET_ERROR) {
///TL;DR ...
                WSACleanup();
                return 1;
            }
            printf("Bytes sent: %d\n", iSendResult);
        }
        else if (iResult == 0)
            printf("Connection closing...\n");
        else  {
///TL;DR ...
            WSACleanup();
            return 1;
        }

    } while (iResult > 0);

    // <<shutdown the connection since we're done>>
    iResult = shutdown(ClientSocket, SD_SEND);
    if (iResult == SOCKET_ERROR) {
///TL;DR ...
        WSACleanup();
        return 1;
    }

    // <<cleanup>>
    closesocket(ClientSocket);
    WSACleanup();

    return 0;
}

     2022/09/08 15:20, Автор сайта          # 

Достаточно развитый макроязык позволяет расширять базовый синтаксис, что в свою очередь, позволяет сделать, например, другой, более расширенный и удобный язык на этом метаязыке. Не нравится синтаксис Форта или Лиспа? Ну ок, прикрутите через макросы паскалевский или сишный. Или свой собственный.

Макросистема тоже не столь важна по себе, сколько её возможности как средства реализации метаязыка.

Ну если посмотреть примеры применений, для чего используются макросы. Посмотрим, например, в библиотеку Qt и порядок её сборки, а также любых примеров на Qt.

Язык является низкоуровневым — когда программы на этом языке переполнены подробной информацией о несущественном.

Алан Перлис

решил реализовать "С++, сделанный правильно" — то есть, D.

Non sequitur (по крайней мере, не всегда), да и не чисто оно вовсе. Дело там нечистое технически, функционально нечистое

     2022/09/08 15:03, Gudleifr          # 

А не говорит ли возможность улучшения синтаксиса языка о том, что действующий синтаксис не слишком хорош?

     2022/09/08 21:59, void          # 

2) Если программа неизменна и неизменны подключаемые библиотеки, то бывают у одинаковых компиляторов разные результаты компиляции?

Да нет же, компиляторы формируют одинаковый исполняемый код или выдают одинаковую ошибку.

     2022/09/08 22:50, void          # 

#include <stdio.h>
#define asd45 45
#define asd43 43

#define cat( x, y )     x ## y
#define xcat( x, y ) cat( x, y )

int main () {
   printf ("%d\n",  xcat(xcat( asd, 4), D)  );
 return 0;
}

gcc h.c -DD=3 -o h3.exe
gcc h.c -DD=5 -o h5.exe

     2022/09/08 23:51, Автор сайта          # 

#include <windows.h> подключит разные библиотеки, и сформирует разный исполняемый код в зависимости определены или нет WIN32_LEAN_AND_MEAN, NOGDI, NOCRYPT, и т. п.

дефолтные переменные окружения

У одинаковых компиляторов разные результаты тоже бывают — соберите например clang-ом, msvc или gcc C++-ный код.

Тоже будете говорить, что рекурсия детерминирована?

     2022/09/08 22:55, void          # 

     2022/09/08 23:01, Gudleifr          # 

А кому нужны «языки задачи»?

     2022/09/08 23:02, void          # 

#define min(a,b)  a<b?a:b

     2022/09/09 14:24, Автор сайта          # 

посмотрите на любое оконное приложение — вы увидите, что набор "кнопок", "боксов" и "менюшек" образует вполне себе "язык"

Сюда же недетерминированность раскрытия неправильного #define min(a,b) a<b?a:b

     2022/09/09 14:42, Gudleifr          # 

Графический интерфейс — это как-то сбоку. Нельзя сказать, что между ним и макросами связь более тесная, чем между ним и языком программирования без макросов. Нельзя сказать, что макросы в результате развития стали графическим интерфейсом, то есть «языком задачи».

invoke	SetLightSource,GL_LIGHT0,ADDR LightSourcePosition,ADDR LightAmbient
invoke	SetLightSource,GL_LIGHT1,ADDR LightSource2Position,ADDR Light2Ambient
invoke	SetLightSource,GL_LIGHT2,ADDR LightSource3Position,ADDR Light3Ambient
invoke	CreateSphere,1,GLU_FILL,GLU_SMOOTH,ADDR Sphere1Color,ADDR Sphere1Radius,sphere1Parts
mov	GlSphere1,eax
invoke	CreateSphere,2,GLU_FILL,GLU_SMOOTH,ADDR Sphere2Color,ADDR Sphere2Radius,sphere2Parts
mov	GlSphere2,eax
invoke	CreateSphere,3,GLU_FILL,GLU_SMOOTH,ADDR Sphere3Color,ADDR Sphere3Radius,sphere3Parts
mov	GlSphere3,eax

     2022/09/13 23:50, Бурановский дедушка          # 

     2022/09/14 00:09, Gudleifr          # 

Возможность создавать новые языки внутри языка для выполнения той или иной задачи — очень мощное средство

И вот тут начинаются проблемы

     2022/10/19 18:31, Виктор          # 

StrLen = @strlen(ConstStr);

     2022/10/20 15:06, Автор сайта          # 

     2022/10/31 21:16, void          # 

Люди хотят выполнить поставленную задачу, а не выучить язык, который поможет сделать работу ровно один раз, а после нигде не пригодится. Для посторонних людей идея освоить ваш язык — это вложение, которое едва ли окупится. А вот изучение чего-то стандартизированного — это инвестиция на всю жизнь. Поэтому скорее они заново перепишут ваш код и уже потом выучат его. Так на свет и появляются бесчисленные диалекты для одной прикладной сферы. Люди спорят об эстетике, идеологии, архитектуре и прочих маловажных вещах. А миллионы строк кода пишутся, чтобы через несколько месяцев кануть в небытие.

Ребята, пишущие на Lisp, прошли через это в 80-х. Они поняли, что чем больше прикладных элементов языка будут стандартизированы, тем лучше. Так на свет появился Common Lisp. И он оказался огромен. Стандарт INCITS 226–1994 насчитывает 1153 страницы. Этот рекорд 17 лет спустя побил только C++ со стандартом ISO/IEC 14882:2011 (1338 страниц). С++ приходится тащить за собой неподъемный багаж наследия, хотя он не всегда был таким большим. Common Lisp был создан по большей части с нуля.

Языку программирования не следует быть настолько огромным. В этом нет необходимости. Ему просто нужна хорошая стандартная библиотека, заполненная всевозможными полезными штуками, чтобы людям не пришлось изобретать велосипеды.

Языку программирования не следует быть настолько огромным. В этом нет необходимости. Ему просто нужна хорошая стандартная библиотека, заполненная всевозможными полезными штуками, чтобы людям не пришлось изобретать велосипеды.

     2022/10/31 21:48, void          # 

Графический интерфейс — это как-то сбоку. Нельзя сказать, что между ним и макросами связь более тесная, чем между ним и языком программирования без макросов. Нельзя сказать, что макросы в результате развития стали графическим интерфейсом, то есть «языком задачи

Добавить свой отзыв

Написать автору можно на электронную почту
mail(аt)compiler.su